Alpha-Beta Hybrid Quantum Associative Memory Using Hamming Distance

Abstract

This work presents a quantum associative memory (Alpha-Beta HQAM) that uses the Hamming distance for pattern recovery. The proposal combines the Alpha-Beta associative memory, which reduces the dimensionality of patterns, with a quantum subroutine to calculate the Hamming distance in the recovery phase. Furthermore, patterns are initially stored in the memory as a quantum superposition in order to take advantage of its properties. Experiments testing the memory’s viability and performance were implemented using IBM’s Qiskit library.

1. Introduction

Quantum computing is an emerging area of computing based on the principles of quantum mechanics. In it, information is represented by quantum states, generally using qubits as the basic unit of storage, and the properties of quantum mechanics such as superposition, are exploited in order to improve the processing speed. Consequently, in recent years, there has been an increasing interest for new developments in the field [1,2,3]. One of these new developments is the creation of quantum algorithms that can provide a quadratic or even an exponential speed-up compared to their classical counterparts. Among the best known quantum algorithms are those of Shor and Grover et al. [4,5], of which different versions have been developed for several areas. Quantum machine learning is one of the particular interests for this work.

Machine learning (ML) is based on the minimization of a constrained multivariate function, and its algorithms are used for data mining and data visualization techniques [6]. In particular, associative memories are a specific class of machine learning algorithms that perform the task known as “retrieval”. In order to take advantage of quantum computing, the idea of a quantum associative memory (QAM) arose similarly to a Hopfield network, although its quantum formulation did not require a reference to artificial neurons [7].

To date, there exist some proposals of quantum associative memories; however, it is worth commenting that the first time they were mentioned was by Ventura et al. in [7], where Grover’s algorithm is used as the main approach. Subsequently, other approaches have been used: quantum associative memories including linear and nonlinear algorithms by Zhou et al. [8], in which the quantum matrix is constructed using binary decision diagrams; in [9], the authors proposed a QAM that performs image recognition for face detection using the Gabor transform; multidirectional associative memories [10,11,12], where fuzzy inference is used, and by means of different layers, it is able to be noise tolerant; in another interesting work [13], the authors propose a QAM that is used as a tool for medical personnel to obtain the diagnosis of four tropical diseases.

In this work, a hybrid quantum associative memory (HQAM) is proposed, using the Alpha-Beta support vector machine [14,15] at the learning phase and the quantum Hamming distance subroutine at the retrieval phase. It should be mentioned that it is considered hybrid because it combines both classical and quantum computing to obtain the greatest potential of both parts.

The advantage of this model over a classical model lies in the reduction of operations at the recovery or retrieval phase when calculating the Hamming distance, since it takes advantage of the parallelism that allows the superposition of patterns in the trained memory.

2. Materials and Methods

2.1. Basic Concepts on Associative Memories

Some of the basic concepts regarding the theory of associative memories in classical computing are explained below. Their operation is divided into two phases:

1.

Learning phase (generation)

2.

Retrieval phase (operation)

The fundamental purpose of an associative memory is to correctly recall complete patterns from possibly altered input patterns as this is the most attractive feature of associative memories. In the particular case where the patterns have only binary data, the only possible types of alterations (i.e., noise) are additive, subtractive or mixed. Thus, an associative memory M can be formulated as an input-output system [16]:

$$x\to \begin{array}{|c|}\hline M\\ \hline\end{array}\to y$$

(1)

The input pattern is represented by a column vector, denoted by x, and the output pattern by a column vector, denoted by y. Each of the input patterns form an association with the corresponding output pattern, the notation for this association is similar to that of an ordered pair, e.g., the x and y patterns in the schematic form the association (x, y); a specific association is denoted as (x^k, y^k), where k is a positive integer. The associative memory M is represented by a matrix whose i j component is denoted as m_ij [17]. The matrix M is generated from a finite set of associations that is known as the fundamental set of associations or simply as the fundamental set. The cardinality of the fundamental set is denoted by p. If μ is an index, the fundamental set is represented as follows:

$$\left\{\left(x^{\mu },y^{\mu }\right)|\mu = 1,2,\dots ,p\right\}$$

(2)

The patterns that form the associations of the fundamental set are called fundamental patterns. If it holds that x^μ = y^μ, for ∀μ ∈ {1, 2, …, p}, the memory is said to be autoassociative, otherwise, it is called heteroassociative. It is possible for the fundamental patterns to be altered by different types of noise, thus, in order to differentiate an altered pattern from its fundamental counterpart, a tilde is used over the pattern, that is, ${\tilde{x}}^k$ denotes an altered version of the fundamental pattern x^k. When the memory M receives an altered pattern ${\tilde{x}}^{\omega }$ as input (ω ∈ {1, 2, …, p}, and M responds with the corresponding fundamental output pattern y^ω, it is said that the memory recall is correct.

Two sets A and B, need to be specified; the components of the column vectors, representing both input and output patterns, are elements of the set A, whereas the components of the matrix M are elements of B. There are no prerequisites or limitations on the choice of these two sets, so they do not necessarily have to be different or have special characteristics.

The positive integer numbers n and m are used to represent the dimension of the input and output patterns respectively. Then the fundamental input and output pattern can be represented as:

$$x^{\mu } = {\left(x_1^{\mu },x_2^{\mu },\dots ,x_n^{\mu }\right)}^t = \left(\begin{array}{c}{x}_1^{\mu }\\ x_2^{\mu }\\ ⋮\\ x_n^{\mu }\end{array}\right)\in A^n$$

(3)

$$y^{\mu } = {\left(y_1^{\mu },y_2^{\mu },\dots ,y_m^{\mu }\right)}^t = \left(\begin{array}{c}{y}_1^{\mu }\\ y_2^{\mu }\\ ⋮\\ y_m^{\mu }\end{array}\right)\in A^m$$

(4)

2.2. Alpha-Beta HQAM Algorithm

The architecture of the proposed Alpha-Beta HQAM model is shown in Figure 1, and the detailed algorithm flow is summarized as following the figure:

1.

Preprocessing is performed to reduce the number of qubits required. Based on the Alpha-Beta SVM associative model, it is intended to take advantage of only that information which is not repeated in the patterns of the fundamental set. At result of this point, there will be two fundamental sets: the restricted fundamental set and the negated restricted fundamental set, as is further explained bellow.

2.

A segmentation of the patterns with a length of n = 4 is performed, assuming that they are binary images (0 white, 1 black). Once this is completed, partial fundamental sets are formed to start training the Alpha-Beta HQAM. Its principal objective is to mitigate the limited number of available qubits and to make it feasible to run experiments using Qiskit SDK.

3.

The training set is encoded into a superimposed quantum state with the equal probability amplitudes: $|m\rangle = \frac{1}{\sqrt{n}}{\sum }_{i = 1}^n|x^i\rangle$, where x_i is the i-th binary pattern of length n. The storage complexity of this algorithm is a linear function related to the number of patterns in the training set.

4.

The retrieval algorithm computes the Hamming distance between the input and all overlapping patterns in the quantum state of the memory. It indicates the probability that an input pattern is in memory, based on the results of its distance distribution over all stored patterns at once. This algorithm is described in Section 2.4. This process must be repeated several times until all the subsets of the training set have been recovered.

5.

Once the previous step is finished, the retrieval for each segment (obtained in step 2) of the patterns in the training set is performed and reintegrated to get the original length of the patterns.

2.3. Preprocessing Module

In this first part, the information is preprocessed to reduce its volume and keep only the most relevant information in the fundamental patterns, this is based on the Alpha-Beta SVM associative model [18], the details are as follows.

2.3.1. The α and β Operators

In this model, the main mathematics used are binary operators designed for the original Alpha-Beta associative memories [15]. They are based on two binary operators: the α operator used in the learning phase and the β operator for the retrieval phase.

The sets are defined A = {0, 1} and B = {0, 1, 2}, then: the binary operator α: A × A → B and the binary operator β: B × A → A are defined in

Table 1. Operators α and β.

α: A × A → B			β: B × A → A
x	y	α(x,y)	x	y	β(x,y)
0	0	1	0	0	0
0	1	0	0	1	0
1	0	2	1	0	1
1	1	1	1	1	1
			2	0	1
			2	1	1

, where ∨ is the max operator and ∧ is the min operator. The sets A and B, the operators α and β, together with the operators ∧ and ∨, form the algebraic system that is the mathematics basis for Alpha-Beta Associative Models.

2.3.2. Alpha-Beta SVM Associative Model

Some important definitions within the Alpha-Beta SVM associative model are explained below.

A zero vector is defined as the vector whose components are all of value 0, and is denoted 0. A one vector is defined as the vector whose components are all of value 1, and is denoted by 1.

Let A = {0, 1} be a binary set, x and y are two vectors, x,y ∈ Aⁿ, n ∈ ${\mathbb{Z}}^{+}$, with x,y ≠ 0,1. The auxiliary c and k_i are defined as:

$$c = {\wedge }_{j = 1}^n j, \mathrm{where} x_j = 1 \mathrm{and}{k}_i = \sum _1^i{x}_i, \mathrm{where} i \in \left\{1,2,\dots ,n\right\}.$$

(5)

with k being a positive integer number which can have a value between 1 and r inclusive.

• Elimination: The elimination of the vector y with respect to the vector x can be obtained as follows:

  1.

  Define the index c according to Equation (5);

  2.

  Eliminate the components x_c and y_c;

  3.

  Decrease the indices of the x_i and y_i, where c < i ≤ n if they exist;

  4.

  Obtain the eliminated vectors ε₁(x) and ε₁(y), the dimension of the vectors are decreased to n − 1.

  If the elimination in y according to x is applied continually with:

  $$c = {\wedge }_{j = 1}^{n-i}j \mathrm{where} {\left[{\epsilon }_i\left(x\right)\right]}_j = 1,0 \le i \le k_n$$

  (6)

  in the k-th iteration, the transformed vectors are denoted ε_k(x) and ε_k(y).
• Restriction: Continue to repeat the elimination, until the valid k-th iteration, in other words, ε_{(k − 1}(x) ≠ 0, andε_k(x) = 0, we get a new vector $y \in A^{n - k_n}$, which is the restriction of y with respect to x, denoted by ${y|}_x$. In this definition, the vector y is really eliminated by the corresponding component with respect to those components of the vector x with a value of 1
  Let $x = \left(\begin{array}{c}1\\ 0\\ 1\\ 0\end{array}\right)$ and $y = \left(\begin{array}{c}0\\ 1\\ 1\\ 1\end{array}\right)$; obtain ${y|}_x$:

  $$\stackrel{c = 1}{\to }{\epsilon }_1\left(x\right) = \left(\begin{array}{c}0\\ 1\\ 0\end{array}\right),{\epsilon }_1\left(y\right) = \left(\begin{array}{c}1\\ 1\\ 1\end{array}\right)\stackrel{c = 3}{\to }{\epsilon }_2\left(x\right) = \left(\begin{array}{c}0\\ 0\end{array}\right),{\epsilon }_2\left(y\right) = \left(\begin{array}{c}1\\ 1\end{array}\right)$$

  (7)
  Therefore ${y|}_x = {\epsilon }_2\left(y\right) = \left(\begin{array}{c}1\\ 1\end{array}\right)$.

Let A = {0, 1} be a binary set, x and z are two vectors x ∈ A_n, z ∈ A_m, n, $m \in {\mathbb{Z}}^{+}$ and m = n − k_n, with x,z ≠ 0, 1..

• Insertion: The insertion of the vector z with respect to the vector x can be obtained as follows:

  1.

  Define the index c according to Equation (5);

  2.

  Shift the components z_i to z_i+1, where c ≤ i ≤ m;

  3.

  Insert z_c = 1, assign x_c = 0;

  4.

  Obtain the inserted vectors I₁(x) and I₁(y), the dimension of the vector z increased to m + 1.

  If the insertion in z according to x is applied continually with:

  $$c = {\wedge }_{j = 1}^{n-i}j \mathrm{where} {\left[I_i\left(x\right)\right]}_j = 1,0\le i\le k_n$$

  (8)

  in the k-th iteration, the transformed vectors are denoted I_k(x) and I_k(z).
• Expansion: Continue to repeat the insertion, until the valid k-th iteration, in other words, I_{(k − 1)}(x) ≠ 0, and I_k(x) = 0, we get a new vector z ∈Aⁿ, which is the expansion of z with respect to x, denoted by ${z|}^x$. In this definition, the vector z is really inserted with a value of 1 to the corresponding position with respect to those components of the vector x with a value of 1. For example,
  Let $x = \left(\begin{array}{c}1\\ 1\\ 0\\ 0\end{array}\right)$ and $y = \left(\begin{array}{c}1\\ 0\end{array}\right)$; obtain ${y|}^x$:

  $$\stackrel{c = 1}{\to }{I}_1\left(x\right) = \left(\begin{array}{c}0\\ 1\\ 0\\ 0\end{array}\right),I_1\left(y\right) = \left(\begin{array}{c}1\\ 1\\ 0\end{array}\right)\stackrel{c = 2}{\to }{I}_2\left(x\right) = \left(\begin{array}{c}0\\ 0\\ 0\\ 0\end{array}\right),I_2\left(y\right) = \left(\begin{array}{c}1\\ 1\\ 1\\ 0\end{array}\right)$$

  (9)
  Therefore ${y|}^x = I_2\left(y\right) = \left(\begin{array}{c}1\\ 1\\ 1\\ 0\end{array}\right)$.
• Support Vector: Let A = {0, 1}, be the binary set, let x be a vector x ∈ A_n of dimension $n\in {\mathbb{Z}}^{+}$, and $p\in {\mathbb{Z}}^{+}$, $1<p\le 2^n$ is the cardinality of the fundamental set of an Alpha-Beta SVM associative model. The vector S is made up of n binary components, which are calculated from the fundamental set as:

  $$S_i = \left\{\begin{array}{cc}{\wedge }_{k = 1}^{p/2}\beta \left(x_i^{2k-1},x_i^{2k}\right)& \mathrm{if} p \mathrm{is} \mathrm{even},\\ \\ \beta \left[{\wedge }_{k = 1}^{\frac{\left(p-1\right)}{2}}\beta \left(x_i^{2k-1},x_i^{2k}\right),x_i^p\right]& \mathrm{if} p \mathrm{is} \mathrm{odd}\end{array}\right.$$

  (10)

Returning to the current proposal, based on the fundamental set and using Equation (10), a pattern can be obtained that contains the repeated information in all the fundamental patterns, subsequently, it is eliminated from the fundamental set, leaving only the information that differentiates a fundamental pattern from all the others. This repeated information is stored in a vector called Support Vector (S).

Since we are looking for the information that can be more significant in the patterns, the next step is to negate the fundamental set and repeat the procedure described in the previous paragraph, thus obtaining the Negated Support Vector $\left(\widehat{S}\right)$.

By the end of this part, there are two fundamental sets: the restricted fundamental set and the negated restricted fundamental set. Figure 2 shows an example of pattern reduction on a fundamental set and Algorithm 1 shows the process of obtaining the fundamental sets:

Algorithm 1 Alpha-Beta HQAM preprocessing

1: From the Fundamental set, calculate Support Vector (S) as shown in Equation (10).

2: For each $\mu \in \left\{1,2,\dots ,n\right\}$, obtain $x^{\mu }{|}_S$. From these results Restricted Fundamental Set is obtained.

3: For each $\mu \in \left\{1,2,\cdots ,n\right\}$, obtain $\overline{x^{\mu }}$ who is the Negated Fundamental Set.

4: From Negated Fundamental set, calculate Negated Support Vector $\left(\widehat{S}\right)$. Equation (10)

5: For each $\mu \in \left\{1,2,\cdots ,n\right\}$, obtain $\overline{x^{\mu }}{|}_{\widehat{S}}$. From these results Negated Restricted Fundamental Set is obtained.

2.4. Segmentation

At present, commercial quantum computers do not yet exist, however, some are available through platforms such as the IBM Q Experience, where up to five qubits can be freely used. Therefore, in order to be able to recover images that exceed this capacity, in the proposed Alpha-Beta HQAM model the images are segmented into 4-bit patterns considering that they are binary images (0 white and 1 black) to reduce their length.

Figure 3 shows an example of the segmentation process of the Restricted Fundamental Set length, which was calculated as explained in Section 2.3.2, and repeated for the Negated Restricted Fundamental Set.

Once this segmentation is completed, fundamental partial sets are formed to start training the proposed model.

2.5. Training Phase

To use some of the properties of quantum mechanics in this model, it is necessary to pass the fundamental ensemble to the quantum state. That is, to transform the bits into qubits to take advantage of the superposition property. The first step is to obtain the unique patterns of the fundamental sets so that the probabilities are distributed and thus there is no class imbalance. This is undertaken to avoid that the probability is biased and, when retrieving it, the majority class is always taken as the result. At this phase, memory initialization is carried out, which consists of an operation that transforms the training set into quantum states with the same probability. Given p binary patterns $x^i$ of length n, the memory represented as a quantum state is shown as:

$$|m\rangle = \frac{1}{\sqrt{n}}\sum _{i = 1}^n|x^i\rangle$$

(11)

The complexity of this algorithm is linear as a function of the number of patterns in the training set.

A detailed description of how the storage is performed with an n bits pattern dataset as input is given below. Algorithm 2 shows the necessary gates to perform each of the steps:

1.

Three registers are used: first register x of n qubits in which the patterns $x^i$ to store are represented.

2.

An ancilla register u of two qubits sets up in $|01\rangle$ state.

3.

Another register m of n qubits to store the memory, the order is from right to left which is initially prepared in $|0_1,\dots ,0_n\rangle$ state.

4.

The second qubit of the register u, $u_2$, in state, $|0\rangle$ for the stored patterns and the first qubit in $|1\rangle$ for the processing term.

5.

For every pattern $x^i$ in the training set to be stored, if the contents of the patterns and the memory registers are identical, all these qubits will be transformed in $|1\rangle$’s.

6.

The first ancilla qubit $u_1$ of the processing term is transformed from $|0\rangle$, leaving it unchanged for the stored patterns term.

7.

The input pattern $x^i$ is added to the memory register with uniform amplitudes. This is carried out by applying the $C{S}^i$ gate, as shown below:

$$\begin{array}{c}C{S}^i = |0\rangle \langle 0|\otimes I+|1\rangle \langle 1|\otimes S^i\\ \mathrm{where} S^i = \left(\begin{array}{cc}\sqrt{\frac{i-1}{i}}& \frac{1}{\sqrt{i}}\\ \frac{-1}{\sqrt{i}}& \sqrt{\frac{i-1}{i}}\end{array}\right)\end{array}$$

(12)

Further steps apply inverse operations to return the memory to its initial state and prepare it to receive the next pattern. This algorithm runs several times until all the patterns have been processed and stored on $|M\rangle$.

Algorithm 2 Storage algorithm [19]

1: Prepare the initial state $|{\psi }_0^i\rangle = |0_1,\dots ,0_n;01;0_1,\dots ,0_n\rangle$

2: for each $x^i\in$ datum do

3:   Load $x^i$ into quantum register ${|x\rangle }_n$

4:   $|{\psi }_1^i\rangle = {\prod }_{j = 1}^{n}2CNO{T}_{x_j^i{u}_2{m}_j}|{\psi }_0^i\rangle$

5:   $|{\psi }_2^i\rangle = {\prod }_{j = 1}^{n}X{m}_{j}CNO{T}_{x_j^i{m}_j}|{\psi }_1^i\rangle$

6:   $|{\psi }_3^i\rangle = nCNO{T}_{m_1,...,m_n{u}_1}|{\psi }_2^i\rangle$

7:   $|{\psi }_4^i\rangle = C{S}_{u_1{u}_2}^{x+1-i}|{\psi }_3^i\rangle$

8:   $|{\psi }_5^i\rangle = nCNO{T}_{m_1,...,m_n{u}_1}|{\psi }_4^i\rangle$

9:   $|{\psi }_6^i\rangle = {\prod }_{j = n}^{1}CNO{T}_{x_j^i{m}_{j}X{m}_j}|{\psi }_5^i\rangle$

10:    $|{\psi }_7^i\rangle = {\prod }_{j = n}^{n}2CNO{T}_{x_j^i{u}_2{m}_j}|{\psi }_6^i\rangle$

11:    Unload $x^i$ from quantum register ${|x\rangle }_n$

12: end for

2.6. Retrieval Phase

The Hamming distance [20] in classical computing is defined as the count of the number of bits that are different between two patterns of equal length, for example, $0110\leftrightarrow 0001$ has a distance of three. However there is a quantum version of this algorithm that was proposed by Trugenberger [21] where the output is determined by a probability distribution in the memory that has a peak around the stored patterns that are closest with respect to the Hamming distance of the input. If the input pattern is far away from the patterns stored in memory, $|1\rangle$ will be obtained as output. Otherwise, $|0\rangle$ would be obtained.

The following is a detailed description of how retrieval is carried out. Algorithm 3 shows the necessary gates to perform each of the steps.

1.

In the initial step of the algorithm, an overlay of the training set containing the training data is constructed:

$$|M\rangle = \frac{1}{\sqrt{N}}\sum _p^{}|x_1^p\dots x_n^p,c^p\rangle ;$$

(13)

2.

Starting from this, construct the initial state:

$$|{\psi }_0\rangle = \frac{1}{\sqrt{N}}\sum _p^{}|\widetilde{x_1},\dots ,\widetilde{x_n};x_1^p,\dots ,x_n^p;c^p\rangle ;$$

(14)

3.

The initial state consists of three registers, the first contains the input pattern, the second contains the memory $|M\rangle$, and the third contains the ancilla qubit set to zero. During the first step, the ancilla is a superposition through the Hadamard gate, giving rise to:

$$|{\psi }_1\rangle = \frac{1}{\sqrt{N}}\sum _p^N|\widetilde{x_1},\dots ,\widetilde{x_n};x_1^p,\dots ,x_n^p;c^p\rangle \otimes \frac{1}{\sqrt{2}}\left(|0\rangle +|1\rangle \right);$$

(15)

4.

Next, by applying a CNOT gate to all j components of the patterns (${\tilde{x}}_j$ is the control qubit and $x_j$ is the target qubit), followed by an X gate to each of the target qubits, the following is obtained

$$|{\psi }_2\rangle = \frac{1}{\sqrt{N}}\sum _p^N|\widetilde{x_1},\dots ,\widetilde{x_n};d_1^p,\dots ,d_n^p;c^p\rangle \otimes \frac{1}{\sqrt{2}}\left(|0\rangle +|1\rangle \right);$$

(16)

5.

Applying unitary operator $U = exp\left(i\frac{\pi }{2n}\widehat{H}\right)$, where H is a hamiltonian summing over all the components $d_j$, calculate the Hamming distance between $\tilde{x}$ and $x_j$, which obtains:

$$\begin{array}{c}|{\psi }_3\rangle = \frac{1}{\sqrt{2N}}\sum _p^{N}exp\left[i\frac{\pi }{2n}{d}_h\left(\tilde{x},x^p\right)\right]|\widetilde{x_1},\dots ,\widetilde{x_n};d_1^k,\dots ,d_n^p;c^p;0\rangle \\ +\frac{1}{\sqrt{2N}}\sum _p^{N}exp\left[-i\frac{\pi }{2n}{d}_h\left(\tilde{x},x^p\right)\right]|\widetilde{x_1},\dots ,\widetilde{x_n};d_1^k,\dots ,d_n^p;c^p;1\rangle ;\end{array}$$

(17)

6.

Applying Hadamard gate on the last qubit, is obtaining the next state:

$$\begin{array}{c}|{\psi }_4\rangle = \frac{1}{\sqrt{N}}\sum _p^{N}cos\left(\frac{\pi }{2n}{d}_h\left(\tilde{x},x^p\right)\right)|\widetilde{x_1},\dots ,\widetilde{x_n};d_1^p,\dots ,d_n^p;c^p;0\rangle \\ +\frac{1}{\sqrt{N}}\sum _p^{N}sin\left(\frac{\pi }{2n}{d}_h\left(\tilde{x},x^p\right)\right)|\widetilde{x_1},\dots ,\widetilde{x_n};d_1^p,\dots ,d_n^p;c^p;1\rangle ;\end{array}$$

(18)

7.

Qubits $|x\rangle$ and $|c\rangle$ need to be measured.

By measuring $|x\rangle$ and $|c\rangle$ it is possible to know which pattern is the result of the retrieval, unlike the original version of the algorithm, we only can know whether the pattern to be retrieved belongs to the trained memory or not.

Algorithm 3: Quantum Hamming Algorithm

1: Load the input p pattern in the quantum register $|i\rangle$

2: $|{\psi }_0\rangle = \frac{1}{\sqrt{N}}{\sum }_p^{}|\widetilde{x_1},\dots ,\widetilde{x_n};x_1^p,\dots ,x_n^p;c^p\rangle$

3: $|\psi 1\rangle = H_c{\prod }_{j = n}^1|{\psi }_0\rangle$

4: $|{\psi }_2\rangle = {\prod }_{j = 1}^n{X}_{m_j}CNO{T}_{i_j,m_j}|{\psi }_0\rangle$

5: $|{\psi }_3\rangle = {\prod }_{i = 1}^n{\left(C{U}^{-2}\right)}_{c,m_i}{\prod }_{j = 1}^n{U}_{m_j}|{\psi }_1\rangle$

6: $|\psi 4\rangle = H_c{\prod }_{j = n}^{1}CNO{T}_{i_j,m_j}{X}_{m_j}|{\psi }_2\rangle$

7: Measure qubits $|x\rangle$ and $|c\rangle$

8: if c == 0 then

9:   Measure the memory to obtain the desired state.

10:  end if

2.7. Validation Methods

To evaluate the capacity of retrieval of the model proposed in this work, two validation methods belonging to the state of the art of machine learning were used, which are explained below.

• Resubstitution Error (RE): In this method the test set is the same as the training set [22], the formula for calculating it is:

  $$RE = \frac{\mathrm{errors}}{\mathrm{number} \mathrm{of} \mathrm{patients}}$$

  (19)
• Leave One Out: Is a special case of cross-validation where the number of folds equals the number of instances in the dataset. Thus, the learning algorithm is applied once for each instance, using all other instances as a training set and using the selected instance as a single-item test set [23].

3. Results and Discussion

In this section the results obtained in the proposed Alpha-Beta HQAM model are presented and analyzed. Two datasets were chosen, the first one is a set of 10 letters of the alphabet as shown in Figure 4, each of the letters consists of a 5 × 5 pixels image that is binarized to apply the model, considering one to the black pixel and zero to the white pixel. The second one is the digit numbers shown in Figure 4.

For the execution of the experiments, Python language is used with the Qiskit SDK to simulate quantum circuits in a computer. Remembering that the proposal is hybrid, the preprocessing and segmentation part is performed with Python programming and the associative memory phases with the Qiskit SDK. Appendix A shows the code that was used to run the experiments presented below.

The experimental results with these two datasets are presented in five parts. First, the preprocessing of each of the datasets is described. Then, in the second subsection, a summary of the results obtained with the resubstitution error validation method is shown. In the third subsection, the results with the Leave One Out validation method are reported, as well as their corresponding discussion. The fourth subsection shows the result of applying the three types of noise (Additive, Subtractive and Mixed) to the first database and finally in the last subsection a summary of the results and their corresponding discussions are represented.

3.1. Dataset Preprocessing

When preparing the fundamental set, it is composed of 10 patterns and each one has 25 features, then the Support Vector and the Negated Support Vector are calculated and as a result the restricted fundamental sets are obtained.

For the experiment using resubstitution error as the validation method in both datasets, the number of features has no variation on its original state In

Table 2. Number of features in the letters dataset with the resubstitution error as validation method.

	A	B	C	D	E	F	G	H	I	J
Restricted Fundamental Set	25	25	25	25	25	25	25	25	25	25
Negated Restricted Fundamental Set	15	15	15	15	15	15	15	15	15	15

and

Table 3. Number of features in the digit numbers dataset with the resubstitution error as validation method.

	0	1	2	3	4	5	6	7	8	9
Restricted Fundamental Set	25	25	25	25	25	25	25	25	25	25
Negated Restricted Fundamental Set	15	15	15	15	15	15	15	15	15	15

the respective results are shown.

On the other hand, for the experiment using Leave One Out as the validation method, the number of features varies between each letter or number depending on the datasets, the respective results are shown in

Table 4. Number of features in the letters dataset with the Leave One Out as validation method.

	A	B	C	D	E	F	G	H	I	J
Restricted Fundamental Set	25	25	25	25	25	25	25	24	22	25
Negated Restricted Fundamental Set	15	15	15	15	15	15	15	15	15	15

and

Table 5. Number of features in the digit numbers dataset with the Leave One Out as validation method.

	0	1	2	3	4	5	6	7	8	9
Restricted Fundamental Set	25	22	25	25	24	25	25	24	21	25
Negated Restricted Fundamental Set	15	15	15	15	15	15	15	15	15	15

.

At the end of this part, the segmented training sets are formed into 4 bits that upon application of the initialization algorithm become qubits.

3.2. Results with the Resubstitution Error as Validation Method

For this validation method, the retrieval is accurate for each of the images of both fundamental sets in the proposed model. In Figure 5 the results are shown for both datasets, with this it can be said that its forgetting factor is zero. That is, the patterns with which the quantum associative memory is already trained are no longer forgotten during the retrieval phase.

3.3. Results with Leave One out as Validation Method

For this experiment, the results obtained are shown in Figure 6. For these cases, the retrieval could be obtained for most of the images, for the letters there were seven of a set of ten and for the digits six of ten. Notice that although it was not complete in the other cases they were very close approximations.

In the case of the letter dataset, since most of the letters resemble each other, it generates a little confusion in some pixels, perhaps this depends on the length that was chosen for the patterns and does not allow one to have considerably different training from each other.

Analyzing the results of the dataset of numbers, the one with the highest error is one, this may be happening because the other digits are very different from it, so in the learning phase it does not have enough training to obtain a better retrieval. These latter two hypotheses merit further analysis.

In addition, the results were compared with those obtained in Neto et al. [24], they designed a quantum associative memory, where the retrieval phase consists of three parts: Exchange, Quantum Fourier Transform and Grover’s algorithm. To test their method, they used a dataset of 10 letters as shown in Figure 7, in order to directly compare the result with them, a variant of the letters dataset was created to match the letter J.

In Figure 8, item (a) shows the obtained result in [24], item (b) shows the obtained results by the proposed Alpha-Beta HQAM model.

By comparison, for the proposed Alpha-Beta HQAM model, there was a completely correct retrieval for six of the ten letters, while they did not retrieve any correctly, and with respect to the others it is noticeable at a glance that there are fewer incorrect pixels, so it can be said that, in general, the proposed model in the retrieval is better than the one reported in [24] It should be noted that the retrieval phase proposed in the new model is less complex to implement, since only the Quantum Hamming Distance algorithm is used, compared to the others which need three algorithms, increasing the number of quantum gates and more qubits needed

3.4. Noisy Input Data

To further experiment with the proposed memory, different types of noise were applied at $8\%$ (Additive, Subtractive and Mixed) to the original datasets shown in Figure 4. In order to easily identify the type of noise applied, pixels with Additive noise are shown in gray and pixels with Subtractive noise in blue.

For Additive Noise, in the letters dataset, Figure 9 in (a) shows the set to be recovered with noisy, and (b) shows the result obtained by the proposed Alpha-Beta HQAM model. The letters that could not be recovered were $\{C,H\}$, but for the others the recovery was completely correct. It is possible that it was influenced by the fact that the patterns to be recovered had no loss of information in the qubits that make up the letters.

In the digit numbers dataset, Figure 10 in (a) shows the set to be recovered with noisy, and in the same Figure 10 but in (b), the result obtained by the proposed Alpha-Beta HQAM model is shown. Only $\{0,3,5,6,8,9\}$ could be recovered and $\{2,4,7\}$ only varied by one and two pixels respectively, but $\left\{1\right\}$ only had a recovery of half of the original pattern.

For the Subtractive noise, in the letters dataset, the result was not as expected since only three letters $\left\{H,I,J\right\}$ were completely recovered, although for the others one $\left\{C,D,E,F,G\right\}$ or two $\left\{A\right\}$ pixels varied. The results are shown in Figure 11, in (a) are the patterns with subtractive noise and in (b) are the results of the retrieval.

In the digit numbers dataset, the results were favorable because five were complete retrieval $\{3,5,6,8,9\}$. However, for $\{0,2,4,7\}$ it only varied in one pixel and for $\left\{1\right\}$ it failed in two pixels. The results are shown in Figure 12, in (a) are the patterns with subtractive noise and in (b) are the results of the retrieval.

Lastly, for the mixed noise, in the letters dataset, a completely correct retrieval was only obtained for $\left\{B,C,D,F,G,H,I,J\right\}$, in the case of $\left\{A\right\}$ there was only a variation in one pixel. The results are shown in Figure 13, in (a) are the patterns with mixed noise and in (b) are the results of the retrieval.

In addition, for the digit numbers dataset, $\left\{0,2,3,6,7,8\right\}$ were retrieved completely correctly, but $\left\{1,4,5,9\right\}$ only failed in one pixel, so it is very close to a perfect retrieval. The results are shown in Figure 14, in (a) are the patterns with mixed noise and in (b) are the results of the retrieval.

Additionally,

Table 6. Summary table of the accuracy (%) obtained in the experiments of the letters dataset.

	A	B	C	D	E	F	G	H	I	J
Resubstitution Error	100	100	100	100	100	100	100	100	100	100
Leave One Out	100	100	96	100	100	96	100	100	100	96
Additive Noise	100	100	96	100	100	100	100	96	100	100
Substractive Noise	92	96	96	96	96	96	96	100	100	100
Mixed Noise	96	100	100	100	96	100	100	100	100	100

and

Table 7. Summary table of the accuracy (%) obtained in the experiments of the digit numbers dataset.

	0	1	2	3	4	5	6	7	8	9
Resubstitution Error	100	100	100	100	100	100	100	100	100	100
Leave One Out	100	12	88	100	92	100	100	88	100	100
Additive Noise	100	92	96	100	92	100	100	96	100	100
Substractive Noise	96	92	96	100	96	100	100	96	100	100
Mixed Noise	100	96	100	100	96	92	100	100	100	96

show a summary of the results obtained in all the experiments described in the previous sections, these performances are calculated as the percentage of correctly recovered pixels.

4. Conclusions

In this work, a hybrid quantum associative memory was proposed and tested on different datasets. The two main attributes of the proposal are the dimensionality reduction of the input patterns using the Alpha-Beta support vector subroutine, which allows the algorithm to run on currently available quantum hardware; and the use of a quantum subroutine to calculate the Hamming distance in the retrieval phase of the memory. The presented results were obtained using IBM’s Qiskit SDK, and show a competitive performance compared to other state-of-the-art works.

It is important to note that the overall quantum complexity of Alpha-Beta HQAM is precisely because the memory has to be reconstructed for each retrieval. This is a widespread problem among quantum algorithms, since the cost of constructing a specific superposition is high. However, it is worth mentioning that Alpha-Beta HQAM does have an advantage over classical memory for retrievals of less than one training. Specifically, for a single retrieval, the advantage is huge: $O\left(n\right)$ versus $O\left(mn\right)$. This advantage can be used for specific applications in quantum noise correction, for example, if an algorithm is run once, then memory can be used to recover the noise-free version of the output.

An interesting potential extension of this proposal includes the realization of experiments with patterns of higher dimension (more attributes) in order to analyze the retrieval performance of the memory in datasets with this specific feature, and even include efficient initialization protocols to reduce quantum complexity in the training phase.