grupo4_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Redes Neurais Quânticas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introdução"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "As redes neurais artificiais são modelos computacionais para aprendizagem de máquina que ganharam significativa força nos últimos anos devido ao aumento do volume de dados e na capacidade de processamento de placas dedicadas. Esta tecnologia vem impactando todas as áreas de produção como agricultura, saúde, mineração, transportes, dentre outras. Dentre as possibilidade de plataformas para realização da computação das redes neurais artificiais, os computadores quânticos têm se mostrado uma possibilidade factível para gerar valor para essa área.\n",
    "\n",
    "Uma propriedade da Mecânica Quântica é a de processar e armazenar grandes vetores e matrizes complexas e realizar operações lineares em tais vetores, resultando em um aumento exponencial na capacidade de desenvolvimento de redes neurais diretamente implementadas em um computador quântico.\n",
    "\n",
    "O modelo mais simples de rede neural artificial foi proposto por Rosenblatt em 1957, uma vetor de valores reais $I$ com dimensão $m$, que representa o input de informações, e um vetor  de valores reais $W$ que representa os pesos da rede. O output da rede é dado pelo produto interno entre os vetores $I$ e $W$ que resulta numa probabilidade associada a uma decisão binária (sim/não). Nas implementações mais simples $I$ e $W$ possuem valores binários e apesar de serem limitados, são a base das redes neurais mais complexas que existem hoje em dia.\n",
    "\n",
    "![](img/rede.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementação do artigo \"An artificial neuron implemented on an actual quantum processor\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No artigo “An artificial neuron implemented on an actual quantum processor” os autores propõem uma alternativa inspirada pela rede neural de Rosenblatt. Primeiramente os vetores de input e pesos de dimensão $M$ são computados no computador quântico usando $N$ qubits, de modo que $M = 2^N$. Isso explicita a vantagem informacional do computador quântico. Os autores também implementam um procedimento para gerar múltiplos estados de emaranhamento que permitiram diminuir os recursos computacionais necessários para gerar o algoritmo.\n",
    "\n",
    "![](img/circuito.png)\n",
    "\n",
    "De maneira prática, o sistema quântico é inicializado numa operação unitária $U_i$, que representa a entrada de dados, segue para um operação unitária $U_w$ que representa os pesos da rede neural e o resultado é extraído por meio de um bit auxiliar (ancilla) que é usado para aplicar uma porta NOT multi controlada a fim de mensurar o estado de ativação do perceptron. A mensuração da ancila produz um output do estado ativado do perceptron com probabilidade $|C_m−1|^2$.\n",
    "    \n",
    "\n",
    "![](img/image6.png)\n",
    "\n",
    "Como observado no circuito acima, vamos definir o circuito $U_i$ que será a entrada representativa dos dados. No exemplo demonstrado no artigo foram simuladas imagens 4x4 pixels que totalizam 16 pixels, cada um representando um valor binário (branco ou preto) que será implementado no algoritmo quântico por meio de uma inversão de sinal da porta lógica $Z$ e $C_nZ$.\n",
    "\n",
    "![](img/image5.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Criação do Circuito"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\dell\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\qiskit\\__init__.py:56: RuntimeWarning: Could not import the Aer provider from the qiskit-aer package. Install qiskit-aer or check your installation.\n",
      "  RuntimeWarning)\n"
     ]
    }
   ],
   "source": [
    "import qiskit as qk\n",
    "import math\n",
    "pi = math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "nqubits = 5 # define nqubits (4+ancilla)\n",
    "q = qk.QuantumRegister(nqubits)\n",
    "c = qk.ClassicalRegister(1)\n",
    "aux = qk.QuantumRegister(2) # Registrador auxiliar para o n-z-controlado\n",
    "circuit = qk.QuantumCircuit(q, aux, c)\n",
    "\n",
    "#============================\n",
    "# MULTI-CONTROLLED GATES\n",
    "#============================\n",
    "\n",
    "def ccz(circ, q1, q2, q3, aux1):\n",
    "# Apply Z-gate to a state controlled by 3 qubits\n",
    "    circ.ccx(q1, q2, aux1)\n",
    "    circ.cz(aux1, q3)\n",
    "    # cleaning the aux bit\n",
    "    circ.ccx(q1, q2, aux1)\n",
    "    return circ\n",
    "\n",
    "def cccz(circ, q1, q2, q3, q4, aux1, aux2):\n",
    "# Apply Z-gate to a state controlled by 4 qubits\n",
    "    circ.ccx(q1, q2, aux1)\n",
    "    circ.ccx(q3, aux1, aux2)\n",
    "    circ.cz(aux2, q4)\n",
    "    # cleaning the aux bits\n",
    "    circ.ccx(q1, q2, aux1)\n",
    "    circ.ccx(q3, aux1, aux2)\n",
    "    return circ\n",
    "\n",
    "def ccccx(circ, q1, q2, q3, q4, q5, aux1, aux2):\n",
    "    circ.ccx(q1, q2, aux1)\n",
    "    circ.ccx(q3, q4, aux2)\n",
    "    circ.ccx(aux2, aux1, q5)\n",
    "    # cleaning the aux bits\n",
    "    circ.ccx(q3, q4, aux2)\n",
    "    circ.ccx(q1, q2, aux1)\n",
    "    return circ\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matriz Ui - Input de Dados da Rede Neural Quântica\n",
    "![](img/image8.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sign-flip Algorithm (brute force)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "states marked:  0000\n",
      "states marked:  0001\n",
      "states marked:  1010\n",
      "         ┌───┐                       ┌───┐┌───┐                            »\n",
      "q2_0: |0>┤ X ├──■────────────■───────┤ X ├┤ X ├──■─────────────────■───────»\n",
      "         ├───┤  │            │       ├───┤├───┤  │                 │       »\n",
      "q2_1: |0>┤ X ├──■────────────■───────┤ X ├┤ X ├──■─────────────────■───────»\n",
      "         ├───┤  │            │       └───┘├───┤  │  ┌───┐          │       »\n",
      "q2_2: |0>┤ X ├──┼────■───────┼────■───────┤ X ├──┼──┤ X ├──■───────┼────■──»\n",
      "         ├───┤  │    │       │    │  ┌───┐└───┘  │  └───┘  │       │    │  »\n",
      "q2_3: |0>┤ X ├──┼────┼───■───┼────┼──┤ X ├───────┼─────────┼───■───┼────┼──»\n",
      "         └───┘  │    │   │   │    │  └───┘       │         │   │   │    │  »\n",
      "q2_4: |0>───────┼────┼───┼───┼────┼──────────────┼─────────┼───┼───┼────┼──»\n",
      "              ┌─┴─┐  │   │ ┌─┴─┐  │            ┌─┴─┐       │   │ ┌─┴─┐  │  »\n",
      "q3_0: |0>─────┤ X ├──■───┼─┤ X ├──■────────────┤ X ├───────■───┼─┤ X ├──■──»\n",
      "              └───┘┌─┴─┐ │ └───┘┌─┴─┐          └───┘     ┌─┴─┐ │ └───┘┌─┴─┐»\n",
      "q3_1: |0>──────────┤ X ├─■──────┤ X ├────────────────────┤ X ├─■──────┤ X ├»\n",
      "                   └───┘        └───┘                    └───┘        └───┘»\n",
      " c1_0: 0 ══════════════════════════════════════════════════════════════════»\n",
      "                                                                           »\n",
      "«      ┌───┐                                 \n",
      "«q2_0: ┤ X ├───────■────────────■────────────\n",
      "«      ├───┤┌───┐  │            │       ┌───┐\n",
      "«q2_1: ┤ X ├┤ X ├──■────────────■───────┤ X ├\n",
      "«      └───┘├───┤  │            │       └───┘\n",
      "«q2_2: ─────┤ X ├──┼────■───────┼────■───────\n",
      "«      ┌───┐└───┘  │    │       │    │  ┌───┐\n",
      "«q2_3: ┤ X ├───────┼────┼───■───┼────┼──┤ X ├\n",
      "«      └───┘       │    │   │   │    │  └───┘\n",
      "«q2_4: ────────────┼────┼───┼───┼────┼───────\n",
      "«                ┌─┴─┐  │   │ ┌─┴─┐  │       \n",
      "«q3_0: ──────────┤ X ├──■───┼─┤ X ├──■───────\n",
      "«                └───┘┌─┴─┐ │ └───┘┌─┴─┐     \n",
      "«q3_1: ───────────────┤ X ├─■──────┤ X ├─────\n",
      "«                     └───┘        └───┘     \n",
      "«c1_0: ══════════════════════════════════════\n",
      "«                                            \n"
     ]
    }
   ],
   "source": [
    "#========================================================\n",
    "# MARK EACH STATE FROM THE IMAGE MATRIX\n",
    "#========================================================\n",
    "\n",
    "matrix =  [1, 1, 0, 0,\n",
    "          0, 0, 0, 0, \n",
    "          0, 0, 1, 0, \n",
    "          0, 0, 0, 0]\n",
    "\n",
    "# capture number of qubits needed for the system\n",
    "nbase_states = str( int(math.sqrt(len(matrix))) )\n",
    "nbase_states = '{0:0'+nbase_states+'b}'\n",
    "\n",
    "# function for automated UI SF generation\n",
    "def autoMarkCircuitSF(matrix, circuit, nbase_states):\n",
    "    ''' identify number of qubits needed for the base states,\n",
    "        identify wich states to be marked, \n",
    "        create circuit based on state bits\n",
    "    '''\n",
    "    # identify positions to be marked with Z-GATE\n",
    "    circuits_config = []\n",
    "    for i in range(len(matrix)):\n",
    "        if matrix[i] == 1:\n",
    "            state_bits = nbase_states.format(i)\n",
    "            print('states marked: ',state_bits)\n",
    "            # apply NOT to qubits with '0' in position\n",
    "            for bit_index in range(len(state_bits)): \n",
    "                if state_bits[bit_index] == '0':\n",
    "                    circuit.x(q[bit_index])\n",
    "            # MARK STATE \n",
    "            cccz(circuit, q[0], q[1], q[2], q[3], aux[0], aux[1]) # MARK STATE \n",
    "            # apply NOT to qubits with '0' in position\n",
    "            for bit_index in range(len(state_bits)): \n",
    "                if state_bits[bit_index] == '0':\n",
    "                    circuit.x(q[bit_index])\n",
    "    return circuit\n",
    "\n",
    "# apply UI\n",
    "autoMarkCircuitSF(matrix, circuit, nbase_states)\n",
    "\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matriz Uw - Pesos da Rede Neural Quântica\n",
    "![](img/image7.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# First Z-gate layer\n",
    "circuit.barrier()\n",
    "circuit.z(q[1])\n",
    "circuit.z(q[2])\n",
    "    \n",
    "# Controlled Z\n",
    "circuit.cz(q[1], q[3])\n",
    "circuit.cz(q[0], q[2])\n",
    "circuit.cz(q[0], q[1])\n",
    "\n",
    "circuit.barrier()\n",
    "circuit = ccz(circuit, q[1], q[2], q[3], aux[0])\n",
    "\n",
    "circuit.barrier()\n",
    "circuit = ccz(circuit, q[0], q[1], q[3], aux[0])\n",
    "\n",
    "circuit.barrier()\n",
    "circuit = cccz(circuit, q[0], q[1], q[2], q[3], aux[0], aux[1])\n",
    "\n",
    "circuit.barrier()\n",
    "# Hadamard on all qubits but ancilla\n",
    "for i in range(nqubits-1):\n",
    "    circuit.h(q[i])\n",
    "\n",
    "# Not on all qubits but ancilla\n",
    "for i in range(nqubits-1):\n",
    "    circuit.x(q[i])\n",
    "\n",
    "# print circuit\n",
    "# circuit.qasm()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](img/image12.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4-Toffoli final e medição\n",
    "![](img/image10.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qiskit.circuit.instructionset.InstructionSet at 0x171c92c8>"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit = ccccx(circuit, q[0], q[1], q[2], q[3], q[4], aux[0], aux[1])\n",
    "circuit.measure(q[4], c[0])\n",
    "#circuit.qasm()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](img/image13.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Uw\n",
    "\n",
    "Como dito, a primeira fase do algoritmo consiste em realizar o produto interno entre um vetor $i$ de entrada e outro vetor $w$ de pesos. Para realizar isso, são usados dois operadores unitários. Um deles, $U_w$, tem a seguinte visualização geométrica\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](img/image01.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primeiramente, em verde, é feita uma projeção do vetor $|ψi⟩$ no vetor $|ψw⟩$. Então, $U_w$ rotaciona $|ψw⟩$ até alinhá-lo com $|111...11⟩$ e também rotaciona $|ψi⟩$ na mesma proporção. O produto interno $i·w$ é representado pela projeção de $U_w|ψi⟩$ no eixo $|111...11⟩$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No artigo, são sugeridas duas abordagens: Força bruta a partir de sucessivas rotações e uma abordagem utilizando hipergrafos. A segunda, sugere uma definição pouco conhecida, mas nada mirabolante."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](img/grafohipergrafo.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nos grafos, se as arestas são relacionamentos, esses relacionamentos são de 1:1. Ou seja, um relacionamento (uma aresta) não pode sair de um vértice em direção a vários outros. Nos hipergrafos, no entanto, isso é possível. Neles, uma aresta pode direcionar-se a vários outros vértices. Um $k$-hipervertice é um hipergrafo cujas arestas conectam $k$ vertices. Dessa forma, um grafo é basicamente um 2-uniforme hipergrafo. Por isso, diz-se que os grafos são um caso especial de hipergrafos, em que arestas ligam somente dois vértices.\n",
    "\n",
    "Esses hipergrafos são interessantes, uma vez que os estados de hipergrafo cobrem todas as possibilidades de estados REW e, como pode ser visto abaixo, é possível encontrar o circuito quantico associado a um hipergrafo. Além disso, é possível definir o hipergrafo associado a um específico estado de REW, bem como a visualização gráfica desse estado. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](img/hipergrafocircuito.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para gerar o circuito correspondente a um grafo simples ou hipergrafo, basta realizar as seguintes operações:\n",
    "1. Cada vértice terá um qubit correspondente.\n",
    "2. Cada vértice deve ser associado ao estado de superposição $|+⟩$.\n",
    "3. Para cada 2 vertices conectados, existirá um $Z$-controlado entre eles.\n",
    "\n",
    "Quando $k=1$, o circuto é representado por portas $Z$ em cada qubit. Quando $k > 1$, "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](img/image3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estados REW"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os estados REW (Real Equally Weighted) são uma classe de estados que estão presentes na inicialização de diversos algorítimos como o de Grover e Deutsch-Jozsa. Na prática, se traduz em uma superposição uniforme de todos os estados da base. Dado um x na base $\\{0, 1\\}^n$ e uma função binária $f$, chamada de função relativa do estado REW, podemos defini-lo da seguinte forma:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](img/image4.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Geração dos arquivos de Entrada\n",
    "\n",
    "Conforme citado anteriormente, o neurônio proposto percebe com estímulo, ou recebe como entrada, um vetor $\\vec{i}$, de tamanho $j$, formado pelos valores $i_j$ que corresponde aos pixels da imagem de entrada. Considerado uma imagem quadrada de tamanho 4, conforme a Figura abaixo, então é possível observar que cada pixel possui um valor binário que se refere a posição desse pixel. Adicionalmente, cada elemento da imagem possui um correspondente em $\\vec{i}$, dessa forma, $i_0$ possuirá o valor da imagem na possição $0000$, enquanto que $i_1$ o valor em $0001$ e assim sucessivamente até $i_{j-1}$ que possuirá o valor da posição $1111$. É importante destacar que $i_j \\in \\{0,1\\}$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](img/exemplo.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diante desse cenário, foram criadas duas funções para auxiliar na criação das imagens de entrada, a primeira chamada de $\\textit{gerar_entrada_padrao(n)}$, essa função cria $({n-2})^2$ imagens, sendo $n$ o tamanho da imagem quadrada. Já a segunda função denominada, $\\textit{gerar_entrada_aleatoria(n, m)}$, cria $n$ arquivos de saida, de forma que cada arquivo possui $m$ valores positivos, ou seja, com valor $1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from random import randrange\n",
    "\n",
    "#funcao para geracao dos arquivos de entrada com o padrao +\n",
    "#input: \n",
    "#     n tamanho da imagem\n",
    "#output:\n",
    "#     arquivos com as matrizs geradas conforme o tamanho n definido\n",
    "def gerar_entrada_padrao(n):\n",
    "    for i in range (1, n-1):\n",
    "        for j in range (1, n-1):\n",
    "            imagem = np.zeros((n, n), dtype=np.uint8)\n",
    "            imagem[i-1][j] = 1\n",
    "            imagem[i][j] = 1\n",
    "            imagem[i+1][j] = 1\n",
    "            imagem[i][j] = 1\n",
    "            imagem[i][j-1] = 1\n",
    "            imagem[i][j] = 1\n",
    "            imagem[i][j+1] = 1\n",
    "            \n",
    "            np.savetxt('input/input_{}_{}_{}.txt'.format(n, i, j), imagem, delimiter=' ', fmt='%s')\n",
    "\n",
    "#funcao para geracao dos arquivos de entrada de forma aleatoria\n",
    "#input: \n",
    "#     n tamanho da imagem\n",
    "#     m quantidade de numeros aleatorios gerados\n",
    "#output:\n",
    "#     arquivos com as matrizs geradas conforme o tamanho n definido\n",
    "def gerar_entrada_aleatoria(n, m):  \n",
    "    for i in range (0, n):\n",
    "        imagem = np.zeros((n, n), dtype=np.uint8)\n",
    "        for j in range (0, m):\n",
    "            r = randrange(n)\n",
    "            s = randrange(n)\n",
    "            imagem [r][s] = 1\n",
    "    \n",
    "        np.savetxt('input/input_{}.txt'.format(i), imagem, delimiter=' ', fmt='%s')\n",
    "\n",
    "n = 4 #tamanho da imagem\n",
    "m = 6 #quantidade de numeros aleatorios\n",
    "\n",
    "gerar_entrada_padrao(n)\n",
    "gerar_entrada_aleatoria(n, m)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Após a chamada das funções anteriores, é possível observar os arquivos gerados da seguinte forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 0 0]\n",
      " [1 1 1 0]\n",
      " [0 1 0 0]\n",
      " [0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "def definir_vetor(imagem):\n",
    "    vetor = np.zeros((n, n), dtype=np.uint8)\n",
    "    cont = 0\n",
    "    for linha in imagem.readlines():\n",
    "        #print (linha)\n",
    "        valores = linha.split()\n",
    "        i = 0\n",
    "        for valor in valores:\n",
    "            vetor[cont][i] = valor\n",
    "            i += 1\n",
    "        cont += 1\n",
    "    return vetor\n",
    "\n",
    "arquivo_padrao = open('input/input_{}_1_1.txt'.format(n), 'r')\n",
    "vetor = definir_vetor(arquivo_padrao)    \n",
    "\n",
    "print(vetor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pqm import *\n",
    "\n",
    "memoria = PQM(n*n)\n",
    "\n",
    "#memoria.load_data(vetor)"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}