quantum_neural_models.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32606757",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Quantum Artificial Neuron implementations based on papers:\n",
    "# \"An artificial neuron implemented on an actual quantum processor\", Tacchino et al., 2019, and\n",
    "# \"Quantum computing model of an artificial neuron with continuously valued input data\", Mangini et al., 2020.\n",
    "# Using libraries: \n",
    "# qiskit v. 0.26.0\n",
    "# tabulate v. 0.8.9\n",
    "# matplotlib v. 3.4.2\n",
    "# Author: Eduardo Barreto Brito/CIn UFPE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90a2b8e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install qiskit\n",
    "# !pip install tabulate\n",
    "# !pip install itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4e6b68d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import matplotlib\n",
    "import math\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "36945474",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import *\n",
    "from tabulate import tabulate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a88d3628",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find(word, character):\n",
    "    return [i for i, ltr in enumerate(word) if ltr == character]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9c0bf96d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class QuantumArtificialNeuron():\n",
    "    def __init__(self, qubit_amount, add_ancilla = True):\n",
    "        # We'll have [qubit_amount] qubits + 1 ancilla\n",
    "        self._qubits_amount = qubit_amount\n",
    "        self._quantum_registers = QuantumRegister(qubit_amount, 'q')\n",
    "        self._ancilla = QuantumRegister(1, 'ancilla')\n",
    "        \n",
    "        # The classical register is only to be able to measure the response\n",
    "        self._classical_register = ClassicalRegister(1, 'c')\n",
    "        \n",
    "        # Gathering the possible combinations between the QuBits (00, 01, 10, 11...)\n",
    "        self._possible_qubits = self.get_possible_qubits(qubit_amount)\n",
    "        \n",
    "        if add_ancilla:\n",
    "            self._circuit = QuantumCircuit(self._quantum_registers, self._ancilla, self._classical_register)\n",
    "        else:\n",
    "            self._circuit = QuantumCircuit(self._quantum_registers)\n",
    "        return\n",
    "        \n",
    "    def get_possible_qubits(self, qubit_amount):\n",
    "        \"\"\" Gets all the possibilities for the amount of qubits. \n",
    "                Eg. for qubit_amount = 2, it will return ['00', '01', '10', '11'] \"\"\"\n",
    "        \n",
    "        inputs = []\n",
    "        for x in map(''.join, itertools.product('01', repeat=qubit_amount)):\n",
    "            inputs.append(x)\n",
    "        return inputs\n",
    "    \n",
    "    def append_hadamard_gates(self):\n",
    "        \"\"\" Appends a barrier + Hadamard (h) gates to all QuBits \"\"\"\n",
    "        \n",
    "        self._circuit.barrier()\n",
    "        for qr in self._quantum_registers:\n",
    "            self._circuit.h(qr)\n",
    "        return\n",
    "\n",
    "    def append_not_gates_to_0_qubits(self, qubits):\n",
    "        \"\"\" Appends Not (x) gates to all QuBits that are 0. \n",
    "                E.g. for qubit 100, x gates will be added on QuBit 1 and 2.\"\"\"\n",
    "        \n",
    "        qr_num = 0\n",
    "        for char_index in range(len(qubits)):\n",
    "            qubit = qubits[char_index]\n",
    "            if qubit == '0':\n",
    "                self._circuit.x(self._quantum_registers[qr_num])\n",
    "            qr_num += 1\n",
    "        return\n",
    "    \n",
    "    def show_qubits_to_input_amplitudes_table(self, input):\n",
    "        \"\"\" Prints a table with all QuBits to its respective amplitude.\n",
    "            E.g. [1, -1, 1, -1]:\n",
    "            00 -> 1\n",
    "            01 -> -1\n",
    "            10 -> 1\n",
    "            11 -> -1\"\"\"\n",
    "        \n",
    "        headers = []\n",
    "        index = 0\n",
    "        for qr in self._quantum_registers:\n",
    "            headers.append(\"q\" + str(index))\n",
    "            index += 1\n",
    "        headers.append(\"ampl\")\n",
    "        \n",
    "        qubits = []\n",
    "        index = 0\n",
    "        for entry in input:\n",
    "            qubit = []\n",
    "            qubits_string = self._possible_qubits[index]\n",
    "            \n",
    "            for char_index in range(len(qubits_string)):\n",
    "                qubit.append(qubits_string[char_index])\n",
    "            \n",
    "            qubit.append(str(entry))\n",
    "            qubits.append(qubit)\n",
    "            \n",
    "            index += 1\n",
    "        \n",
    "        print(tabulate(qubits, headers=headers))\n",
    "        return\n",
    "    \n",
    "    def build_circuit(self, input, weight):\n",
    "        \"\"\" Builds the whole circuit using the input/weight values for amplitudes \"\"\"\n",
    "        \n",
    "        self.append_hadamard_gates()\n",
    "        self.append_circuit(input)\n",
    "        self.append_circuit(weight)\n",
    "        self.append_hadamard_gates()\n",
    "        self.finish_circuit()\n",
    "        return\n",
    "    \n",
    "    def get_neuron_activation_probability(self, num_of_simulations = 8192):\n",
    "        \"\"\" Simulates the Quantum circuit and returns the probability of the ancilla being 1, \n",
    "            which is the same as the probability of the neuron being activated\"\"\"\n",
    "        \n",
    "        simulator = Aer.get_backend('qasm_simulator')\n",
    "        result = execute(an._circuit, backend = simulator, shots=num_of_simulations).result()\n",
    "        return result.get_counts(self._circuit)['1']/num_of_simulations\n",
    "    \n",
    "    def finish_circuit(self):\n",
    "        \"\"\" Appends a Not gate (X gate) to all QuBit a CNot gate using all registers \n",
    "                as controllers and ancilla as target, and measure the ancilla to the classical register\"\"\"\n",
    "        \n",
    "        for qubit in self._quantum_registers:\n",
    "            self._circuit.x(qubit)\n",
    "            \n",
    "        self._circuit.mcx(self._quantum_registers, self._ancilla)\n",
    "        self._circuit.measure(self._ancilla, self._classical_register)\n",
    "        return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "09c6c84e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BruteForceQan(QuantumArtificialNeuron):\n",
    "    def append_circuit(self, input):\n",
    "        \"\"\" Appends the circuit responsible to mimic the input based on Tacchino et al. 2019 approach of Brute Force\"\"\"\n",
    "        \n",
    "        qr = self._quantum_registers\n",
    "        circuit = self._circuit\n",
    "        if len(input) > len(self._possible_qubits):\n",
    "            raise Exception(\"The number of values of the input is bigger than the possible amount of values\")\n",
    "            \n",
    "        index = 0\n",
    "        for entry in input:\n",
    "            if entry < 0:\n",
    "                self._circuit.barrier()\n",
    "                self.append_not_gates_to_0_qubits(self._possible_qubits[index])\n",
    "                \n",
    "                # A multiple-controlled rotation z with lambda = pi is the same as having multiple-controlled z (e^(pi)i = 1)\n",
    "                self._circuit.mcrz(math.pi, self._quantum_registers[:-1], self._quantum_registers[-1])\n",
    "                \n",
    "                self.append_not_gates_to_0_qubits(self._possible_qubits[index])\n",
    "            index += 1                \n",
    "        return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3dd1edee",
   "metadata": {},
   "outputs": [],
   "source": [
    "class HSGSQan(QuantumArtificialNeuron):\n",
    "    def reset_current_state(self):\n",
    "        self._amplitude_state = [1] * len(self._possible_qubits)\n",
    "        \n",
    "    def update_current_amplitude_state(self, qubits_1s_indexes):\n",
    "        \"\"\" Changes the amplitude signal of every QuBit that contains 1 on qubits_1s_indexes\"\"\"\n",
    "        \n",
    "        # When updating the amplitude current state, we need to switch the amplitude of every QuBit that the \n",
    "        # Z gate we just applied affects. That means that for every QuBit combination that all of the \n",
    "        # controlling QuBit is 1 we need to invert the amplitude, thus we need to iterate through all possible qubits\n",
    "        index = 0\n",
    "        for possible_qubit in self._possible_qubits:\n",
    "            should_invert_amplitude = True\n",
    "            \n",
    "            # And then check where all the controlling QuBits are 1\n",
    "            for qubit_1_index in qubits_1s_indexes:\n",
    "                should_invert_amplitude = should_invert_amplitude and possible_qubit[qubit_1_index] == \"1\"\n",
    "            \n",
    "            # If all the controlling QuBits are one, we just invert the current amplitude\n",
    "            if should_invert_amplitude:\n",
    "                self._amplitude_state[index] = -self._amplitude_state[index]\n",
    "                \n",
    "            index += 1\n",
    "        return\n",
    "    \n",
    "    def append_circuit(self, input):\n",
    "        \"\"\" Appends the circuit responsible to mimic the input based on Tacchino et al. 2019 approach of HSGS \n",
    "        (hypergraph states generation subroutine) \"\"\"\n",
    "        \n",
    "        qr = self._quantum_registers\n",
    "        circuit = self._circuit\n",
    "        self.reset_current_state()\n",
    "        \n",
    "        if len(input) > len(self._possible_qubits):\n",
    "            raise Exception(\"The number of values of the input is bigger than the possible amount of values\")\n",
    "        \n",
    "        for num_of_1s in range(1, self._qubits_amount + 1):\n",
    "            index = 0\n",
    "            for possible_qubit in self._possible_qubits:\n",
    "                # This means that we already have what we want, thus we can go back!\n",
    "                if input == self._amplitude_state:\n",
    "                    return\n",
    "                \n",
    "                # We found one difference. We must insert Z gates in the correct places\n",
    "                elif input[index] != self._amplitude_state[index] and possible_qubit.count(\"1\") == num_of_1s:\n",
    "                    qubits_one = find(possible_qubit, \"1\")\n",
    "                    control_qbits = []\n",
    "                    for qubit_index in qubits_one:\n",
    "                        control_qbits.append(self._quantum_registers[qubit_index])\n",
    "                    \n",
    "                    self._circuit.barrier()\n",
    "                    \n",
    "                    if len(control_qbits) == 1:\n",
    "                        self._circuit.z(control_qbits[0])\n",
    "                    else:\n",
    "                        # A multiple-controlled rotation z with lambda = pi is the \n",
    "                        # same as having multiple-controlled z (e^(pi)i = 1)\n",
    "                        self._circuit.mcrz(math.pi, control_qbits[:-1], control_qbits[-1])\n",
    "                    \n",
    "                    # Now we can finally update our current state\n",
    "                    self.update_current_amplitude_state(qubits_one)\n",
    "                    \n",
    "                index += 1            \n",
    "        return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2d5ea3d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PhaseEncodingHSGSQan(QuantumArtificialNeuron):\n",
    "    def append_circuit(self, input):\n",
    "        qr = self._quantum_registers\n",
    "        circuit = self._circuit\n",
    "        if len(input) > len(self._possible_qubits):\n",
    "            raise Exception(\"The number of values of the input is bigger than the possible amount of values\")\n",
    "            \n",
    "        #TODO: Implement PhaseShiftQnn with HSGS\n",
    "        # Most likely won't be implemented, since it was not part of neither Tacchino et al. [2019] nor Mangini et al. [2020]\n",
    "        return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e2e1f775",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PhaseEncodingBruteForceQan(QuantumArtificialNeuron):\n",
    "    def append_circuit(self, input):\n",
    "        \"\"\" Appends the circuit responsible to mimic the input based on Mangini et al. 2020 approach of the continuously\n",
    "            valued quantum neuron model\"\"\"\n",
    "        \n",
    "        qr = self._quantum_registers\n",
    "        circuit = self._circuit\n",
    "        if len(input) > len(self._possible_qubits):\n",
    "            raise Exception(\"The number of values of the input is bigger than the possible amount of values\")\n",
    "            \n",
    "        index = 0\n",
    "        for entry in input:\n",
    "            self._circuit.barrier()\n",
    "            self.append_not_gates_to_0_qubits(self._possible_qubits[index])\n",
    "\n",
    "            # As we're having continuous valued entries, we can pass the entry already.\n",
    "            self._circuit.mcrz(abs(entry), self._quantum_registers[:-1], self._quantum_registers[-1])\n",
    "\n",
    "            self.append_not_gates_to_0_qubits(self._possible_qubits[index])\n",
    "            index += 1\n",
    "        return"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}