QAOA_for_Ising.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tjB6BhZPB1W3",
        "outputId": "cb6809ef-b236-4a4f-a2f9-04efa611028d"
      },
      "outputs": [],
      "source": [
        "from qiskit import *\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "# Import from Qiskit Aer noise module\n",
        "from qiskit.providers.aer import AerSimulator\n",
        "from qiskit.providers.aer.noise import NoiseModel\n",
        "from qiskit.providers.aer.noise import QuantumError, ReadoutError\n",
        "from qiskit.providers.aer.noise import pauli_error\n",
        "from qiskit.providers.aer.noise import depolarizing_error\n",
        "from qiskit.providers.aer.noise import thermal_relaxation_error\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib\n",
        "\n",
        "%matplotlib inline\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "3AkrzCrLHgn3"
      },
      "outputs": [],
      "source": [
        "def construct_noise(nqubits):\n",
        "      \n",
        "    noise = NoiseModel()\n",
        "\n",
        "    ### ----------------- Bit-flip error ----------------- \n",
        "    # Error probabilities\n",
        "    p_gate1_1qubit = 0.00031344\n",
        "    p_gate1_2qubit = 0.0085165\n",
        "\n",
        "    # QuantumError objects\n",
        "    error_gate1 = pauli_error([('X',p_gate1_1qubit), ('I', 1 - p_gate1_1qubit)])\n",
        "    error_gate2 = pauli_error([('X',p_gate1_2qubit), ('I', 1 - p_gate1_2qubit)])\n",
        "    error_gate2 = error_gate2.tensor(error_gate2)\n",
        "\n",
        "    ### ----------------- Thermal relaxation ----------------- \n",
        "    # T1 and T2 values for alll= qubits\n",
        "    T1s = np.random.normal(153.404e3, 0, nqubits) # Sampled from normal distribution mean 50 microsec\n",
        "    T2s = np.random.normal(62.028e3, 0, nqubits)  # Sampled from normal distribution mean 50 microsec\n",
        "\n",
        "    # Truncate random T2s <= T1s\n",
        "    T2s = np.array([min(T2s[j], 2*T1s[j]) for j in range(nqubits)])\n",
        "\n",
        "    # Instruction times (in nanoseconds)\n",
        "    time_sx = 35.55555555555556\n",
        "    time_rz = 35.55555555555556\n",
        "    time_cx = 368\n",
        "    time_measure = 5351.111\n",
        "\n",
        "    # QuantumError objects\n",
        "    errors_measure = [thermal_relaxation_error(t1, t2, time_measure) for t1, t2 in zip(T1s, T2s)]\n",
        "    errors_sx = [thermal_relaxation_error(t1, t2, time_sx) for t1, t2 in zip(T1s, T2s)]\n",
        "    errors_rz = [thermal_relaxation_error(t1, t2, time_rz) for t1, t2 in zip(T1s, T2s)]\n",
        "    errors_cx = [[thermal_relaxation_error(t1a, t2a, time_cx).expand(thermal_relaxation_error(t1b, t2b, time_cx)) for t1a, t2a in zip(T1s, T2s)] for t1b, t2b in zip(T1s, T2s)]\n",
        "\n",
        "\n",
        "    ### ----------------- Compose both noise models ----------------- \n",
        "    # Add errors to noise model\n",
        "    for j in range(nqubits):\n",
        "        noise.add_quantum_error(errors_measure[j], \"measure\", [j])\n",
        "        noise.add_quantum_error(error_gate1.compose(errors_sx[j]), \"sx\", [j])\n",
        "        noise.add_quantum_error(error_gate1.compose(errors_rz[j]), \"rz\", [j])\n",
        "        for k in range(nqubits):\n",
        "            noise.add_quantum_error(error_gate2.compose(errors_cx[j][k]), \"cx\", [j, k])\n",
        "\n",
        "    return noise\n",
        "\n",
        "\n",
        "def describe_qubit(gate, properties):\n",
        "    us = 1e6\n",
        "    ns = 1e9\n",
        "    T1_avg = 0\n",
        "    T2_avg = 0\n",
        "    error_avg = 0\n",
        "    length_avg = 0\n",
        "\n",
        "    print(\"\\nFor the\", gate, \"gate:\\n\")\n",
        "\n",
        "    if gate == 'cx':\n",
        "        n = 0\n",
        "        for gate_i in props.gates:\n",
        "            if 'cx' in gate_i.name:\n",
        "                n += 1\n",
        "                print(\" - {0} gate on qubits {1} error rate is {2}\\n\"\n",
        "                      \" - Gate duration of {3} nanoseconds\\n\".format(gate_i.name, gate_i.qubits, gate_i.parameters[0].value, gate_i.parameters[1].value))\n",
        "                error_avg += gate_i.parameters[0].value\n",
        "                length_avg += gate_i.parameters[1].value\n",
        "        print(\"The avg. gate error = {0}\\n\"\n",
        "              \"The avg. gate duration = {1} nanoseconds\\n\".format(error_avg/n, length_avg/n))\n",
        "\n",
        "    else:\n",
        "        n = config.n_qubits\n",
        "        for i in range(n):\n",
        "            print(\"Qubit {0} has a \\n\"\n",
        "                  \"  - T1 time of {1} microseconds\\n\"\n",
        "                  \"  - T2 time of {2} microseconds\\n\"\n",
        "                  \"  - Gate error of {3}\\n\"\n",
        "                  \"  - Gate duration of {4} nanoseconds\\n\"\n",
        "                 .format(\n",
        "                      i,\n",
        "                      properties.t1(i) * us,\n",
        "                      properties.t2(i) * us,\n",
        "                      properties.gate_error(gate, i),\n",
        "                      properties.gate_length(gate, i) * ns))\n",
        "            T1_avg += properties.t1(i) * us\n",
        "            T2_avg += properties.t2(i) * us\n",
        "            error_avg += properties.gate_error(gate, i)\n",
        "            length_avg += properties.gate_length(gate, i) * ns\n",
        "        print(\"The avg. T1 time = {0} microseconds\\n\"\n",
        "              \"The avg. T2 time = {1} microseconds\\n\"\n",
        "              \"The avg. gate error = {2}\\n\"\n",
        "              \"The avg. gate duration = {3} nanoseconds\\n\".format(T1_avg/n, T2_avg/n, error_avg/n, length_avg/n))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "oBpo_3nZHliC"
      },
      "outputs": [],
      "source": [
        "real_qc = False\n",
        "Noise = False\n",
        "nqubits = 4\n",
        "\n",
        "if real_qc:\n",
        "    # replace TOKEN with your API token string (https://quantum-computing.ibm.com/lab/docs/iql/manage/account/ibmq)\n",
        "    provider = IBMQ.load_account()\n",
        "    # Get backend for experiment\n",
        "    provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')\n",
        "    backend = provider.get_backend('ibmq_lima')\n",
        "    \n",
        "    config = backend.configuration()\n",
        "    print(\"This backend is called {0}, and is on version {1}. It has {2} qubit{3}. It \"\n",
        "          \"{4} OpenPulse programs. The basis gates supported on this device are {5}.\"\n",
        "          \"\".format(config.backend_name,\n",
        "                    config.backend_version,\n",
        "                    config.n_qubits,\n",
        "                    '' if config.n_qubits == 1 else 's',\n",
        "                    'supports' if config.open_pulse else 'does not support',\n",
        "                    config.basis_gates))\n",
        "    props = backend.properties()           \n",
        "    describe_qubit('cx', props)\n",
        "    \n",
        "else:\n",
        "    if Noise:\n",
        "        noise = construct_noise(nqubits)\n",
        "    else:\n",
        "        noise = None\n",
        "    backend = AerSimulator(noise_model=noise)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 336
        },
        "id": "x0I9VPzEJVDJ",
        "outputId": "d551dd07-1532-4672-b2b0-c812a1f280f8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The minimum value of the Hamiltonian: -21 the configuration: 0101\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import networkx as nx\n",
        "from itertools import combinations\n",
        "\n",
        "\n",
        "Ising_coeff = [\n",
        "            [0, 2, 3, 4],\n",
        "            [0, 0, 8, 1],\n",
        "            [0, 0, 0, 11],\n",
        "            [0, 0, 0, 0]\n",
        "        ]\n",
        "\n",
        "\"\"\"\n",
        "Ising_coeff = [\n",
        "            [1, 4],\n",
        "            [0, 1]\n",
        "        ]\n",
        "\"\"\"\n",
        "\n",
        "# Visualize the connectivity of the Ising model\n",
        "G = nx.Graph()\n",
        "pairs = []\n",
        "for i in range(0, nqubits):\n",
        "    G.add_node(i, weight = Ising_coeff[i][i])\n",
        "    for j in range(i+1, nqubits):\n",
        "        pairs.append((i, j, Ising_coeff[i][j]))\n",
        "G.add_weighted_edges_from(pairs)\n",
        "labels = {n: str(n) + ';   ' + str(G.nodes[n]['weight']) for n in G.nodes}\n",
        "nx.draw(G, with_labels=True, labels=labels, alpha=0.8, node_size=500)\n",
        "\n",
        "\n",
        "# @jit(nopython=True, parallel=True, fastmath=True)\n",
        "def H_Ising(bitstring, Ising_coeff):\n",
        "    spins = []\n",
        "    for bit in bitstring:\n",
        "        if bit == '0':\n",
        "            spins.append(-1)\n",
        "        elif bit == '1':\n",
        "            spins.append(1)\n",
        "    H = 0\n",
        "    for i in range(0, nqubits):\n",
        "        H += Ising_coeff[i][i]*spins[i]\n",
        "        for j in range(i+1, nqubits):\n",
        "            H += Ising_coeff[i][j]*spins[i]*spins[j]\n",
        "    return H\n",
        "\n",
        "\n",
        "H_min = 10000\n",
        "for i in range(2**len(Ising_coeff)):\n",
        "    bitstring = np.binary_repr(i, nqubits)\n",
        "    if H_Ising(bitstring, Ising_coeff) < H_min:\n",
        "        H_min = H_Ising(bitstring, Ising_coeff)\n",
        "        config_min = bitstring\n",
        "print('The minimum value of the Hamiltonian:', H_min, 'the configuration:', config_min)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "vDfqwYSbJMQT"
      },
      "outputs": [],
      "source": [
        "\n",
        "\n",
        "def compute_expectation(counts, Ising_coeff):   \n",
        "    \"\"\"\n",
        "    Computes expectation value based on measurement results\n",
        "    \"\"\"   \n",
        "    sum = 0\n",
        "    sum_count = 0\n",
        "    for bitstring, count in counts.items():\n",
        "        sum += count*H_Ising(bitstring, Ising_coeff)\n",
        "        sum_count += count\n",
        "    return sum/sum_count\n",
        "\n",
        "\n",
        "# We will also bring the different circuit components that\n",
        "# build the qaoa circuit under a single function\n",
        "def create_qaoa_circ(Ising_coeff, theta): \n",
        "    \"\"\"\n",
        "    Creates a parametrized qaoa circuit\n",
        "    \"\"\"   \n",
        "    p = len(theta)//2  # number of alternating unitaries\n",
        "    qc = QuantumCircuit(nqubits)\n",
        "    \n",
        "    beta = theta[:p]\n",
        "    gamma = theta[p:]\n",
        "    \n",
        "    # initial_state\n",
        "    for i in range(0, nqubits):\n",
        "        qc.h(i)\n",
        "    \n",
        "    for irep in range(0, p):\n",
        "        \n",
        "        # problem unitary\n",
        "        for i in range(nqubits):\n",
        "            for j in range(i+1, nqubits):\n",
        "                if Ising_coeff != 0:\n",
        "                    qc.rzz(2 * Ising_coeff[i][j]*gamma[irep], i, j)\n",
        "        # mixer unitary\n",
        "        for i in range(nqubits):\n",
        "            qc.rz(2 * Ising_coeff[i][i]*gamma[irep], i)\n",
        "            qc.rx(2 * beta[irep], i)\n",
        "            \n",
        "    qc.measure_all()\n",
        "        \n",
        "    return qc\n",
        "\n",
        "# Finally we write a function that executes the circuit on the chosen backend\n",
        "def get_expectation(theta):\n",
        "    \"\"\"\n",
        "    Runs parametrized circuit and get expectation value\n",
        "    \n",
        "    \"\"\"\n",
        "    qc = create_qaoa_circ(Ising_coeff, theta)       \n",
        "    qc = transpile(qc, backend=backend)\n",
        "    if seed:\n",
        "        seed_simulator = 10\n",
        "    else:\n",
        "        seed_simulator = None\n",
        "    counts = backend.run(qc, seed_simulator=seed_simulator, nshots=shots).result().get_counts()       \n",
        "\n",
        "    return compute_expectation(counts, Ising_coeff)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 371
        },
        "id": "lW0r_T-dWzH8",
        "outputId": "5f0baafa-3a5f-47dd-d8f8-2074108531fc"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">global phase: 0\n",
              "        ┌───┐                                 ┌────────────────┐»\n",
              "   q_0: ┤ H ├─■───────■────────────────■──────┤ U3(2,-π/2,π/2) ├»\n",
              "        ├───┤ │ZZ(4)  │                │      └────────────────┘»\n",
              "   q_1: ┤ H ├─■───────┼───────■────────┼────────────■───────────»\n",
              "        ├───┤         │ZZ(6)  │ZZ(16)  │            │           »\n",
              "   q_2: ┤ H ├─────────■───────■────────┼────────────┼───────────»\n",
              "        ├───┤                          │ZZ(8)       │ZZ(2)      »\n",
              "   q_3: ┤ H ├──────────────────────────■────────────■───────────»\n",
              "        └───┘                                                   »\n",
              "meas: 4/════════════════════════════════════════════════════════»\n",
              "                                                                »\n",
              "«                                             ░ ┌─┐         \n",
              "«   q_0: ─────────────────────────────────────░─┤M├─────────\n",
              "«        ┌────────────────┐                   ░ └╥┘┌─┐      \n",
              "«   q_1: ┤ U3(2,-π/2,π/2) ├───────────────────░──╫─┤M├──────\n",
              "«        └────────────────┘┌────────────────┐ ░  ║ └╥┘┌─┐   \n",
              "«   q_2: ─────■────────────┤ U3(2,-π/2,π/2) ├─░──╫──╫─┤M├───\n",
              "«             │ZZ(22)      ├────────────────┤ ░  ║  ║ └╥┘┌─┐\n",
              "«   q_3: ─────■────────────┤ U3(2,-π/2,π/2) ├─░──╫──╫──╫─┤M├\n",
              "«                          └────────────────┘ ░  ║  ║  ║ └╥┘\n",
              "«meas: 4/════════════════════════════════════════╩══╩══╩══╩═\n",
              "«                                                0  1  2  3 </pre>"
            ],
            "text/plain": [
              "global phase: 0\n",
              "        ┌───┐                                 ┌────────────────┐»\n",
              "   q_0: ┤ H ├─■───────■────────────────■──────┤ U3(2,-π/2,π/2) ├»\n",
              "        ├───┤ │ZZ(4)  │                │      └────────────────┘»\n",
              "   q_1: ┤ H ├─■───────┼───────■────────┼────────────■───────────»\n",
              "        ├───┤         │ZZ(6)  │ZZ(16)  │            │           »\n",
              "   q_2: ┤ H ├─────────■───────■────────┼────────────┼───────────»\n",
              "        ├───┤                          │ZZ(8)       │ZZ(2)      »\n",
              "   q_3: ┤ H ├──────────────────────────■────────────■───────────»\n",
              "        └───┘                                                   »\n",
              "meas: 4/════════════════════════════════════════════════════════»\n",
              "                                                                »\n",
              "«                                             ░ ┌─┐         \n",
              "«   q_0: ─────────────────────────────────────░─┤M├─────────\n",
              "«        ┌────────────────┐                   ░ └╥┘┌─┐      \n",
              "«   q_1: ┤ U3(2,-π/2,π/2) ├───────────────────░──╫─┤M├──────\n",
              "«        └────────────────┘┌────────────────┐ ░  ║ └╥┘┌─┐   \n",
              "«   q_2: ─────■────────────┤ U3(2,-π/2,π/2) ├─░──╫──╫─┤M├───\n",
              "«             │ZZ(22)      ├────────────────┤ ░  ║  ║ └╥┘┌─┐\n",
              "«   q_3: ─────■────────────┤ U3(2,-π/2,π/2) ├─░──╫──╫──╫─┤M├\n",
              "«                          └────────────────┘ ░  ║  ║  ║ └╥┘\n",
              "«meas: 4/════════════════════════════════════════╩══╩══╩══╩═\n",
              "«                                                0  1  2  3 "
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "circuit = create_qaoa_circ(Ising_coeff, [1, 1])\n",
        "circuit = transpile(circuit, backend=backend)\n",
        "circuit.draw()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "QaZ4s3ZuT0td"
      },
      "outputs": [],
      "source": [
        "def optimizer(\n",
        "    eps: float, \n",
        "    theta: list[float], \n",
        "    lr: float, \n",
        "    momentum: float\n",
        "):\n",
        "    grad = [0 for t in range(len(theta))]\n",
        "    for i in range(len(theta)):\n",
        "        # Uses a symmetric difference to calulate the gradient\n",
        "        theta[i] += eps\n",
        "        grad[i] = get_expectation(theta)\n",
        "        theta[i] -= 2*eps\n",
        "        grad[i] -= get_expectation(theta)\n",
        "        grad[i] /= 2*eps\n",
        "        theta[i] += eps      \n",
        "        # Update the parameters by gradient descent with momentum\n",
        "        v[i] = momentum*v[i] - lr*grad[i]\n",
        "        theta[i] = theta[i] + v[i]\n",
        "\n",
        "    return theta"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V0GmZqmQXff1",
        "outputId": "51b37e01-f826-460b-f197-1dddbdb9ae14"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The expectation values at iteration = 0 is: 12.9375\n",
            "The expectation values at iteration = 1 is: -11.3359375\n",
            "The expectation values at iteration = 2 is: -10.1640625\n",
            "The expectation values at iteration = 3 is: -14.384765625\n",
            "The expectation values at iteration = 4 is: -15.513671875\n",
            "The expectation values at iteration = 5 is: -15.763671875\n",
            "The expectation values at iteration = 6 is: -16.083984375\n",
            "The expectation values at iteration = 7 is: -15.732421875\n",
            "The expectation values at iteration = 8 is: -15.978515625\n",
            "The expectation values at iteration = 9 is: -17.107421875\n",
            "The expectation values at iteration = 10 is: -16.68359375\n",
            "The expectation values at iteration = 11 is: -16.498046875\n",
            "The expectation values at iteration = 12 is: -17.353515625\n",
            "The expectation values at iteration = 13 is: -16.056640625\n",
            "The expectation values at iteration = 14 is: -15.939453125\n",
            "The expectation values at iteration = 15 is: -17.22265625\n",
            "The expectation values at iteration = 16 is: -17.259765625\n",
            "The expectation values at iteration = 17 is: -17.458984375\n",
            "The expectation values at iteration = 18 is: -17.3984375\n",
            "The expectation values at iteration = 19 is: -17.806640625\n",
            "The expectation values at iteration = 20 is: -17.505859375\n",
            "The expectation values at iteration = 21 is: -17.57421875\n",
            "The expectation values at iteration = 22 is: -17.619140625\n",
            "The expectation values at iteration = 23 is: -17.771484375\n",
            "The expectation values at iteration = 24 is: -17.498046875\n",
            "The expectation values at iteration = 25 is: -17.79296875\n",
            "The expectation values at iteration = 26 is: -17.888671875\n",
            "The expectation values at iteration = 27 is: -17.888671875\n",
            "The expectation values at iteration = 28 is: -17.923828125\n",
            "The expectation values at iteration = 29 is: -17.931640625\n",
            "The expectation values at iteration = 30 is: -17.921875\n",
            "The expectation values at iteration = 31 is: -17.748046875\n",
            "The expectation values at iteration = 32 is: -17.646484375\n",
            "The expectation values at iteration = 33 is: -17.802734375\n",
            "The expectation values at iteration = 34 is: -17.953125\n",
            "The expectation values at iteration = 35 is: -17.994140625\n",
            "The expectation values at iteration = 36 is: -17.990234375\n",
            "The expectation values at iteration = 37 is: -17.984375\n",
            "The expectation values at iteration = 38 is: -17.95703125\n",
            "The expectation values at iteration = 39 is: -17.962890625\n",
            "The expectation values at iteration = 40 is: -18.013671875\n",
            "The expectation values at iteration = 41 is: -18.01171875\n",
            "The expectation values at iteration = 42 is: -17.98046875\n",
            "The expectation values at iteration = 43 is: -18.033203125\n",
            "The expectation values at iteration = 44 is: -18.0\n",
            "The expectation values at iteration = 45 is: -17.95703125\n",
            "The expectation values at iteration = 46 is: -17.97265625\n",
            "The expectation values at iteration = 47 is: -18.0234375\n",
            "The expectation values at iteration = 48 is: -17.986328125\n",
            "The expectation values at iteration = 49 is: -17.99609375\n",
            "The expectation values at iteration = 50 is: -17.998046875\n"
          ]
        }
      ],
      "source": [
        "seed = True\n",
        "shots = 1024\n",
        "eps = 10**-3\n",
        "p = 4\n",
        "lr = 0.0001\n",
        "momentum = 0.5\n",
        "num_steps = 50\n",
        "schedule = [30]\n",
        "lr_decay = 0.1\n",
        "\n",
        "\n",
        "# Initialize the parameters\n",
        "torch.manual_seed(0)\n",
        "theta = torch.empty(int(2*p))\n",
        "torch.nn.init.normal_(theta, mean=0.5, std=0.01)\n",
        "theta = theta.tolist()\n",
        "\n",
        "\n",
        "expectation_list = []\n",
        "theta_list = []\n",
        "# Perform SGD with momentum\n",
        "v = [0 for i in range(int(2*p))]\n",
        "for i in range(num_steps + 1):      # Update the parameters\n",
        "    expectation = get_expectation(theta)\n",
        "    expectation_list.append(expectation)\n",
        "    if i in schedule:      # Learning rate scheduling (step)\n",
        "        lr = lr*lr_decay\n",
        "    theta = optimizer(eps, theta, lr, momentum)\n",
        "    if (i != 0) and (i % 10 == 0):\n",
        "        theta_list.append(theta)\n",
        "    print('The expectation values at iteration =', i, 'is:', expectation)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[12.9375,\n",
              " -11.3359375,\n",
              " -10.1640625,\n",
              " -14.384765625,\n",
              " -15.513671875,\n",
              " -15.763671875,\n",
              " -16.083984375,\n",
              " -15.732421875,\n",
              " -15.978515625,\n",
              " -17.107421875,\n",
              " -16.68359375,\n",
              " -16.498046875,\n",
              " -17.353515625,\n",
              " -16.056640625,\n",
              " -15.939453125,\n",
              " -17.22265625,\n",
              " -17.259765625,\n",
              " -17.458984375,\n",
              " -17.3984375,\n",
              " -17.806640625,\n",
              " -17.505859375,\n",
              " -17.57421875,\n",
              " -17.619140625,\n",
              " -17.771484375,\n",
              " -17.498046875,\n",
              " -17.79296875,\n",
              " -17.888671875,\n",
              " -17.888671875,\n",
              " -17.923828125,\n",
              " -17.931640625,\n",
              " -17.921875,\n",
              " -17.748046875,\n",
              " -17.646484375,\n",
              " -17.802734375,\n",
              " -17.953125,\n",
              " -17.994140625,\n",
              " -17.990234375,\n",
              " -17.984375,\n",
              " -17.95703125,\n",
              " -17.962890625,\n",
              " -18.013671875,\n",
              " -18.01171875,\n",
              " -17.98046875,\n",
              " -18.033203125,\n",
              " -18.0,\n",
              " -17.95703125,\n",
              " -17.97265625,\n",
              " -18.0234375,\n",
              " -17.986328125,\n",
              " -17.99609375,\n",
              " -17.998046875]"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "expectation_list"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[[0.456507094908526,\n",
              "  0.5368775362090532,\n",
              "  0.43822522933644176,\n",
              "  0.46519471593307987,\n",
              "  0.517743436619134,\n",
              "  0.5323087393659517,\n",
              "  0.4694000650005482,\n",
              "  0.5189806468801501],\n",
              " [0.456507094908526,\n",
              "  0.5368775362090532,\n",
              "  0.43822522933644176,\n",
              "  0.46519471593307987,\n",
              "  0.517743436619134,\n",
              "  0.5323087393659517,\n",
              "  0.4694000650005482,\n",
              "  0.5189806468801501],\n",
              " [0.456507094908526,\n",
              "  0.5368775362090532,\n",
              "  0.43822522933644176,\n",
              "  0.46519471593307987,\n",
              "  0.517743436619134,\n",
              "  0.5323087393659517,\n",
              "  0.4694000650005482,\n",
              "  0.5189806468801501],\n",
              " [0.456507094908526,\n",
              "  0.5368775362090532,\n",
              "  0.43822522933644176,\n",
              "  0.46519471593307987,\n",
              "  0.517743436619134,\n",
              "  0.5323087393659517,\n",
              "  0.4694000650005482,\n",
              "  0.5189806468801501],\n",
              " [0.456507094908526,\n",
              "  0.5368775362090532,\n",
              "  0.43822522933644176,\n",
              "  0.46519471593307987,\n",
              "  0.517743436619134,\n",
              "  0.5323087393659517,\n",
              "  0.4694000650005482,\n",
              "  0.5189806468801501]]"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "theta_list"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[-0.0003744922168756257,\n",
              " 0.00034443673329907353,\n",
              " 4.5482562361972225e-05,\n",
              " -0.00025258727478531394,\n",
              " 5.099252371631493e-06,\n",
              " 1.3892708404641515e-05,\n",
              " -0.00021036868859746676,\n",
              " -9.260013866462786e-05]"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "v"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 122
        },
        "id": "WhjeyIroT0wE",
        "outputId": "5a950a34-6893-41a2-c5f4-3ee4f6e79637"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "\"\\nseed = True\\nshots = 1024\\neps = 10**-3\\nmomentum = 0.0\\nnum_steps = 100\\nschedule = [60]\\nlr_decay = 0.1\\n\\np_list = [int(i+1) for i in range(10)]\\nlr_list = [0.5*10**-2, 1*10**-2, 2*10**-2, 5*10**-2, 10*10**-2, 20*10**-2, 50*10**-2]\\n\\np_list = [2]\\nlr_list = [0.01]\\n\\n\\nminimum_list = []\\nlr_best_list = []\\ntheta_best_list = []\\nfor num_p in p_list:\\n    p = num_p\\n    print('\\nFor p =', p, ':')\\n    minimum = 1\\n    for lr in lr_list:\\n        # Initialize the parameters\\n        torch.manual_seed(0)\\n        theta = torch.empty(1, int(2*p))\\n        torch.nn.init.normal_(theta, mean=0.5, std=0.01)\\n        theta = theta.tolist()[0]\\n        # Perform SGD with momentum\\n        v = [0 for i in range(len(theta))]\\n        for i in range(num_steps + 1):      # Update the parameters\\n            if i in schedule:      # Learning rate scheduling (step)\\n                lr = lr*lr_decay\\n            theta = optimizer(eps, theta, lr, momentum)\\n\\n        expectation = get_expectation(theta)\\n        if expectation < minimum:\\n            minimum = expectation\\n            lr_best = lr\\n            theta_best = theta\\n\\n        print('Learning rate =', lr, 'the expectation value =', expectation)\\n\\n    minimum_list.append(minimum)\\n    lr_best_list.append(lr_best)\\n    theta_best_list.append(theta_best)\\n    print('The min. expectation value = ', minimum, 'when learning rate =', lr_best)\\n    print('-----------------Temporary results-----------------')\\n    for i in range(len(minimum_list)): \\n        print('The optimized parameters:',  theta_best_list[i])\\n    print('Min. expectaion value =', minimum_list)\\n    print('Best learning rate =', lr_best_list)\\n\""
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"\"\"\n",
        "seed = True\n",
        "shots = 1024\n",
        "eps = 10**-3\n",
        "momentum = 0.0\n",
        "num_steps = 100\n",
        "schedule = [60]\n",
        "lr_decay = 0.1\n",
        "\n",
        "p_list = [int(i+1) for i in range(10)]\n",
        "lr_list = [0.5*10**-2, 1*10**-2, 2*10**-2, 5*10**-2, 10*10**-2, 20*10**-2, 50*10**-2]\n",
        "\n",
        "p_list = [2]\n",
        "lr_list = [0.01]\n",
        "\n",
        "\n",
        "minimum_list = []\n",
        "lr_best_list = []\n",
        "theta_best_list = []\n",
        "for num_p in p_list:\n",
        "    p = num_p\n",
        "    print('\\nFor p =', p, ':')\n",
        "    minimum = 1\n",
        "    for lr in lr_list:\n",
        "        # Initialize the parameters\n",
        "        torch.manual_seed(0)\n",
        "        theta = torch.empty(1, int(2*p))\n",
        "        torch.nn.init.normal_(theta, mean=0.5, std=0.01)\n",
        "        theta = theta.tolist()[0]\n",
        "        # Perform SGD with momentum\n",
        "        v = [0 for i in range(len(theta))]\n",
        "        for i in range(num_steps + 1):      # Update the parameters\n",
        "            if i in schedule:      # Learning rate scheduling (step)\n",
        "                lr = lr*lr_decay\n",
        "            theta = optimizer(eps, theta, lr, momentum)\n",
        "\n",
        "        expectation = get_expectation(theta)\n",
        "        if expectation < minimum:\n",
        "            minimum = expectation\n",
        "            lr_best = lr\n",
        "            theta_best = theta\n",
        "\n",
        "        print('Learning rate =', lr, 'the expectation value =', expectation)\n",
        "\n",
        "    minimum_list.append(minimum)\n",
        "    lr_best_list.append(lr_best)\n",
        "    theta_best_list.append(theta_best)\n",
        "    print('The min. expectation value = ', minimum, 'when learning rate =', lr_best)\n",
        "    print('-----------------Temporary results-----------------')\n",
        "    for i in range(len(minimum_list)): \n",
        "        print('The optimized parameters:',  theta_best_list[i])\n",
        "    print('Min. expectaion value =', minimum_list)\n",
        "    print('Best learning rate =', lr_best_list)\n",
        "\"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 348
        },
        "id": "UeKPmGBoT0yo",
        "outputId": "4d027d50-84d6-4828-ecfa-c5ac8ddcd7c8"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 504x360 with 1 Axes>"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from qiskit.visualization import plot_histogram\n",
        "\n",
        "qc_result = create_qaoa_circ(Ising_coeff, theta)\n",
        "counts = backend.run(qc_result).result().get_counts()\n",
        "\n",
        "plot_histogram(counts)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ywiNwMYOT79F",
        "outputId": "8e7b2d7e-87fe-4277-9faa-9016dcc26918"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'0110': 1, '0111': 6, '0010': 46, '0101': 408, '1010': 405, '1011': 9, '0011': 8, '0100': 12, '1110': 33, '1101': 45, '1100': 18, '0001': 31, '1000': 2}\n"
          ]
        }
      ],
      "source": [
        "print(counts)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "QAOA_for_Ising.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.9.7 ('base')",
      "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.7"
    },
    "vscode": {
      "interpreter": {
        "hash": "159f4e407912a17e167f5db34c957ad4331db5f294b01a1425dfe1db5ae08f50"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}