Adding Perceptron and its simulation demo notebook

quantum_perceptron/__init__.py

@@ -0,0 +1 @@
+from quantum_perceptron.perceptron import Perceptron

quantum_perceptron/perceptron.py

@@ -0,0 +1,163 @@
+from typing import Dict
+from qiskit import QuantumCircuit, Aer, execute
+from quantum_perceptron.utils import (
+    assert_negative,
+    assert_bits,
+    create_hypergraph_state,
+    get_vector_from_int
+)
+
+
+class Perceptron:
+    def __init__(self,
+                 num_qubits: int,
+                 weight: int = 1,
+                 input: int = 1):
+        """
+        This class creates a quantum perceptron instance which has
+        capability calculate input * weight. Note that we are not applying
+        any non-linearity. Our perceptron design is as per
+        https://arxiv.org/pdf/1811.02266.pdf
+
+        Args:
+          num_qubits: `int` denoting number of qubits in perceptron
+          weight: `int` denoting the weight of the perceptron.
+          input: `int` denoting the data to input to the perceptron.
+        """
+        self.num_qubits = num_qubits
+        assert self.num_qubits > 0, "Number qubits must be positive"
+        assert_negative(weight)
+        self.weight = weight
+        assert_negative(input)
+        self.input = input
+        assert_bits(self.weight, self.num_qubits)
+        assert_bits(self.input, self.num_qubits)
+        self.build_flag = False
+        self.build_circuit()
+
+    def Ui(self):
+        """
+        Sub-circuit to transform input data.
+        """
+        if not self.build_flag:
+            raise RuntimeError("Ui() cannot be called independently.")
+
+        Ui = QuantumCircuit(self.num_qubits)
+
+        # Applying hadamard to first num_qubits
+        for q in range(self.num_qubits):
+            Ui.h(q)
+
+        # Extracting vectors for input
+        input_vector = get_vector_from_int(self.input, self.num_qubits)
+
+        # Applying hypergraph state corresponding to input.
+        Ui = create_hypergraph_state(Ui,
+                                     input_vector,
+                                     self.num_qubits)
+        Ui = Ui.to_gate()
+        Ui.name = "U_i"
+        return Ui
+
+    def Uw(self):
+        """
+        Sub-circuit to transform weight data.
+        """
+        if not self.build_flag:
+            raise RuntimeError("Ui() cannot be called independently.")
+
+        Uw = QuantumCircuit(self.num_qubits)
+
+        # Extracting vectors for weight
+        input_vector = get_vector_from_int(self.weight, self.num_qubits)
+
+        # Applying hypergraph state corresponding to weight.
+        Uw = create_hypergraph_state(Uw,
+                                     input_vector,
+                                     self.num_qubits)
+
+        # Applying hadamard to first num_qubits
+        for q in range(self.num_qubits):
+            Uw.h(q)
+
+        # Applying X gate to first num_qubits
+        for q in range(self.num_qubits):
+            Uw.x(q)
+        Uw = Uw.to_gate()
+        Uw.name = "U_w"
+        return Uw
+
+    def build_circuit(self):
+        """
+        Build quantum circuit corresponding to single perceptron combining
+        input data and weight of the perceptron.
+        """
+        # Creating circuit with num_qubits + 1 (ancilla) qubit.
+        self.circuit = QuantumCircuit(1 + self.num_qubits, 1)
+
+        def toggle_build_flag():
+            """
+            Toggle the build circuit flag. Used to monitor Ui and Uf circuits
+            to ensure that those functions are not called seperately but from
+            the `build_circuit()` function.
+            """
+            self.build_flag = not self.build_flag
+
+        # Append Ui for processing input
+        toggle_build_flag()
+        # self.Ui()
+        self.circuit.append(
+            self.Ui(),
+            list(range(self.num_qubits))
+        )
+        toggle_build_flag()
+
+        # Append Uf for processing input
+        toggle_build_flag()
+        self.circuit.append(
+            self.Uw(),
+            list(range(self.num_qubits))
+        )
+        toggle_build_flag()
+
+        # Toffoli gate at the end with target as ancilla qubit
+        self.circuit.mcx(
+            control_qubits=list(range(self.num_qubits)),
+            target_qubit=self.num_qubits
+        )
+
+        # Measure the last qubit.
+        self.circuit.measure(self.num_qubits, 0)
+
+    def measure_circuit(self, num_iters: int = 1000) -> Dict[str, int]:
+        """
+        Measure the perceptron and get the counts of the final results.
+
+        Args:
+          num_iters: `int` denoting number of iterations to execute circuit.
+
+        Returns: `dict` containing the measurement frequencies.
+        """
+        if not hasattr(self, 'circuit'):
+            raise RuntimeError("The circuit hasn't yet built.",
+                               "Please call build_circuit() first.")
+        backend = Aer.get_backend('qasm_simulator')
+
+        # Execute the circuit
+        job = execute(self.circuit, backend, shots=num_iters)
+
+        # Get result and counts
+        result = job.result()
+        counts = result.get_counts(self.circuit)
+        return dict(counts)
+
+    def save_circuit_image(self,
+                           file_path: str,
+                           output_format: str = "mpl"):
+        """
+        Save circuit to the image file.
+        """
+        if not hasattr(self, 'circuit'):
+            raise RuntimeError("The circuit hasn't yet built.",
+                               "Please call build_circuit() first.")
+        self.circuit.draw(output=output_format, filename=file_path)

quantum_perceptron/tests/test_utils.py

@@ -28,10 +28,11 @@ def test_get_bin_int(data, num_qubits, expected_result):
 
 
 @pytest.mark.parametrize("data, num_qubits, expected_result", [
-    (12, 4, np.array([-1, -1, 1, 1])),
-    (12, 5, np.array([1, -1, -1, 1, 1])),
-    (1, 1, np.array([-1])),
-    (12, 3, False),
+    (12, 4, np.array([1]*12 + [-1, -1, 1, 1])),
+    (12, 5, np.array([1]*28 + [-1, -1, 1, 1])),
+    (1, 1, np.array([1, -1])),
+    (12, 3, np.array([1]*4 + [-1, -1, 1, 1])),
+    (16, 2, False),
     (-5, 2, False)
 ])
 def test_get_vector_from_int(data, num_qubits, expected_result):

quantum_perceptron/utils/__init__.py

@@ -1 +1,2 @@
 from quantum_perceptron.utils.data_utils import *
+from quantum_perceptron.utils.quantum_utils import *

quantum_perceptron/utils/data_utils.py

@@ -16,7 +16,7 @@ def get_bin_int(data: int, num_qubits: Optional[int] = None) -> str:
     """
     assert_negative(data)
     if num_qubits:
-        return bin(data)[2:].zfill(num_qubits)
+        return bin(data)[2:].zfill(np.power(2, num_qubits))
     return bin(data)[2:]
 
 
@@ -24,7 +24,7 @@ def assert_bits(data: int, num_bits: int):
     """
     General method to prevent invalid number of bits.
     """
-    if len(get_bin_int(data)) > num_bits:
+    if len(get_bin_int(data)) > np.power(2, num_bits):
         raise ValueError("data has more bits than num_bits")
 
 
@@ -44,7 +44,7 @@ def get_vector_from_int(data: int, num_qubits: int) -> np.ndarray:
     assert_bits(data, num_qubits)
 
     bin_data = get_bin_int(data, num_qubits)
-    data_vector = np.empty(num_qubits)
+    data_vector = np.empty(np.power(2, num_qubits))
 
     for i, bit in enumerate(bin_data):
         data_vector[i] = np.power(-1, int(bit))

quantum_perceptron/utils/quantum_utils.py

@@ -11,7 +11,8 @@ def append_hypergraph_state(
         circuit: QuantumCircuit,
         data_vector: np.ndarray,
         states: np.ndarray,
-        ones_count: Dict[int, List[int]]) -> QuantumCircuit:
+        ones_count: Dict[int, List[int]],
+        num_qubits: int) -> QuantumCircuit:
     """
     Append the computed hypergraph state to the circuit.
 
@@ -21,11 +22,11 @@ def append_hypergraph_state(
       states: `list` of `str` containing the bit strings for states.
       ones_count: `dict` containing mapping of the count of ones with
         index of states
+      num_qubits: `int` denoting total number of qubits in the circuit.
 
     Returns: `QuantumCircuit` object denoting the circuit containing
       hypergraph states.
     """
-    num_qubits = int(np.log2(len(data_vector)))
     is_sign_inverted = [1] * len(data_vector)
 
     # Flipping all signs if all zero state has coef -1.
@@ -56,7 +57,8 @@ def append_hypergraph_state(
 
 
 def create_hypergraph_state(circuit: QuantumCircuit,
-                            data_vector: np.ndarray) -> QuantumCircuit:
+                            data_vector: np.ndarray,
+                            num_qubits: int) -> QuantumCircuit:
     """
     Creating hypergraph state for specific data vector corresponding to
     the provided data (input or weight value).
@@ -65,16 +67,17 @@ def create_hypergraph_state(circuit: QuantumCircuit,
     Args:
       circuit: `QuantumCircuit` object corresponding to the perceptron.
       data_vector: `np.ndarray` containing the data vector containing -1s & 1s.
+      num_qubits: `int` denoting total number of qubits in the circuit.
 
     Returns: `QuantumCircuit` object denoting the circuit containing
       hypergraph states.
     """
-    num_qubits = int(np.log2(len(data_vector)))
     states = get_possible_state_strings(num_qubits)
     ones_count = get_ones_counts_to_states(states)
     return append_hypergraph_state(
         circuit,
         data_vector,
         states,
-        ones_count
+        ones_count,
+        num_qubits
     )