Tensorflow_Quantum_Sample_Codes.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Tensorflow Quantum Sample Codes.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q1k4985JYC9Y",
        "colab_type": "text"
      },
      "source": [
        "# Topic 3 Tensorflow Quanutm"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xOlTH8HcLYcb",
        "colab_type": "text"
      },
      "source": [
        "## Install Tensorflow Quantum and Cirq"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RPOPslBnXgcd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install tensorflow==2.1.0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8bh78HeTom1Q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install tensorflow-quantum"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V71YFWBQQnyI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install cirq"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a0_RJaOfSWhO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import tensorflow as tf\n",
        "import tensorflow_quantum as tfq\n",
        "\n",
        "import cirq"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DhhQ52dHXXFU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "tf.__version__"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VZAflmrMLVri",
        "colab_type": "text"
      },
      "source": [
        "## Basic Cirq Operations"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e0GAjhQnMVHP",
        "colab_type": "text"
      },
      "source": [
        "### Qubits"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P2rlrOoFkmYA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Create two qubits\n",
        "q0 = cirq.GridQubit(0, 0)\n",
        "q1 = cirq.GridQubit(1, 0)\n",
        "print(q0,q1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gW_WT30PMFHi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Create two qubits\n",
        "q0, q1 = cirq.GridQubit.rect(1, 2)\n",
        "print(q0,q1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I8RHCdq6kyE1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Create two qubits\n",
        "q0,q1 = cirq.LineQubit.range(2)\n",
        "print(q0,q1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v4m9y1cBHdtn",
        "colab_type": "text"
      },
      "source": [
        "#### Ex: Qubits"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WnpCIl54HaHK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "q0, q1, q2 = [cirq.GridQubit(i, 0) for i in range(3)]\n",
        "print(q0,q1,q2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hZwae0LlHN_o",
        "colab_type": "text"
      },
      "source": [
        "### Quantum Gates"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W12WeFJy6XBS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "q0 = cirq.GridQubit(0, 0)\n",
        "q1 = cirq.GridQubit(1, 0)\n",
        "\n",
        "cirq.H(q0)\n",
        "cirq.CNOT(q0, q1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aCWOUGUd4UEl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(cirq.unitary(cirq.X))\n",
        "print(cirq.unitary(cirq.CNOT))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9Ix4weaj5N1B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(cirq.measure(q0,q1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "koohQZT6Zjct",
        "colab_type": "text"
      },
      "source": [
        "#### Ex: Quantum Gates"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FsIUYXIUZZU0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "q0, q1, q2 = [cirq.GridQubit(i, 0) for i in range(3)]\n",
        "\n",
        "cirq.H(q0)\n",
        "cirq.CNOT(q0, q1)\n",
        "cirq.CNOT(q0, q2)\n",
        "print(cirq.measure(q0,q1,q2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hO-22h1VIhf_",
        "colab_type": "text"
      },
      "source": [
        "### Quantum Circuits"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kwVp6yyrIK7_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "q0, q1 = cirq.LineQubit.range(2)\n",
        "\n",
        "circuit = cirq.Circuit()\n",
        "# circuit.append([cirq.H(q0)), cirq.X(q1), cirq.CNOT(q0, q1)])\n",
        "circuit.append(cirq.H(q0))\n",
        "circuit.append(cirq.X(q1))\n",
        "circuit.append(cirq.CNOT(q0, q1))\n",
        "circuit.append(cirq.measure(q0,q1))\n",
        "print(circuit)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e5Qdf70Xamv_",
        "colab_type": "text"
      },
      "source": [
        "#### Ex: Quantum Circuits"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "163yDmkiZpfp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "q0, q1, q2 = cirq.LineQubit.range(3)\n",
        "\n",
        "circuit = cirq.Circuit()\n",
        "circuit.append(cirq.H(q0))\n",
        "circuit.append(cirq.CNOT(q0, q1))\n",
        "circuit.append(cirq.CNOT(q0, q2))\n",
        "circuit.append(cirq.measure(q0,q1,q2))\n",
        "print(circuit)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s-oso0MsQfKX",
        "colab_type": "text"
      },
      "source": [
        "### Simulator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YwQhHT9fkDEK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Create a circuit to generate a Bell State:\n",
        "# sqrt(2) * ( |00> + |11> )\n",
        "bell_circuit = cirq.Circuit()\n",
        "q0, q1 = cirq.LineQubit.range(2)\n",
        "\n",
        "bell_circuit.append(cirq.H(q0))\n",
        "bell_circuit.append(cirq.CNOT(q0,q1))\n",
        "print(bell_circuit)\n",
        "\n",
        "simulator=cirq.Simulator()\n",
        "results=simulator.simulate(bell_circuit)\n",
        "print(results)\n",
        "\n",
        "bell_circuit.append(cirq.measure(q0, q1))\n",
        "results =simulator.run(bell_circuit, repetitions=1000)\n",
        "print(cirq.plot_state_histogram(results))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oQxf4ZP3bCAD",
        "colab_type": "text"
      },
      "source": [
        "#### Ex: Simulator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9VDcvSINtbNl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "bell_circuit = cirq.Circuit()\n",
        "q0, q1,q2  = cirq.LineQubit.range(3)\n",
        "\n",
        "bell_circuit.append(cirq.H(q0))\n",
        "bell_circuit.append(cirq.CNOT(q0,q1))\n",
        "bell_circuit.append(cirq.CNOT(q0,q2))\n",
        "print(bell_circuit)\n",
        "\n",
        "simulator=cirq.Simulator()\n",
        "results=simulator.simulate(bell_circuit)\n",
        "print(results)\n",
        "\n",
        "bell_circuit.append(cirq.measure(q0,q1,q2))\n",
        "results =simulator.run(bell_circuit, repetitions=1000)\n",
        "print(cirq.plot_state_histogram(results))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1iFYpKSzLffX",
        "colab_type": "text"
      },
      "source": [
        "### Parametrized Circuit"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FxhPWtRdu6xm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import sympy\n",
        "import numpy as np\n",
        "\n",
        "q = cirq.GridQubit(1,1)\n",
        "theta = sympy.symbols('theta')\n",
        "circuit = cirq.Circuit(cirq.rx(theta).on(q), cirq.measure(q, key='m'))\n",
        "\n",
        "param_sweep = cirq.Linspace('theta', start=0, stop=np.pi, length=100)\n",
        "\n",
        "# Simulate the sweep\n",
        "simulator = cirq.Simulator()\n",
        "trials = simulator.run_sweep(circuit, param_sweep, repetitions=1000)\n",
        "\n",
        "# Plot all the results\n",
        "x = [trial.params['theta'] for trial in trials]\n",
        "y = [trial.histogram(key='m')[1] / 1000.0 for trial in trials]\n",
        "plt.scatter(x,y)\n",
        "plt.xlabel('theta')\n",
        "plt.ylabel('probability of |1>')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VpX9hij6YR4i",
        "colab_type": "text"
      },
      "source": [
        "# Topic 4 Quantum Machine Learning"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uliIVannPfm8",
        "colab_type": "text"
      },
      "source": [
        "### Convert to Tensor"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zCokjpkyLRh8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "22e8207e-b713-4c8b-ae9e-cd18510125fa"
      },
      "source": [
        "q0, q1 = cirq.GridQubit.rect(1, 2)\n",
        "\n",
        "circuit = cirq.Circuit()\n",
        "circuit.append(cirq.H(q0))\n",
        "circuit.append(cirq.X(q1))\n",
        "circuit.append(cirq.CNOT(q0, q1))\n",
        "circuit.append(cirq.measure(q0,q1))\n",
        "\n",
        "tensor_circuit = tfq.convert_to_tensor([circuit])\n",
        "result = outputs(tensor_circuit)\n",
        "print(result)\n",
        "# same_circuits = tfq.from_tensor(tensor_circuit)\n",
        "# print(same_circuits)"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tf.Tensor([[1.8408706e-07]], shape=(1, 1), dtype=float32)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lpVlLtciUct7",
        "colab_type": "text"
      },
      "source": [
        "### Parametrized Quantum Circuit (PQC) Layer."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lgFNPqybPiin",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "outputId": "d6332edb-2d2f-41d8-8a5d-4907bc4a98a9"
      },
      "source": [
        "q = cirq.GridQubit(0, 0)\n",
        "(a, b, c) = sympy.symbols(\"a b c\")\n",
        "circuit = cirq.Circuit(\n",
        "    cirq.rz(a)(q),\n",
        "    cirq.rx(b)(q),\n",
        "    cirq.rz(c)(q)\n",
        ")\n",
        "measurement = [cirq.X(q), cirq.Y(q), cirq.Z(q)]\n",
        "outputs = tfq.layers.PQC(circuit,measurement)\n",
        "quantum_data = tfq.convert_to_tensor([cirq.Circuit(),cirq.Circuit(cirq.X(q))])\n",
        "res = outputs(quantum_data)\n",
        "res.numpy()"
      ],
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0.23841469, -0.8694439 , -0.4326962 ],\n",
              "       [-0.23841463,  0.86944395,  0.43269598]], dtype=float32)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ira52Et1V20o",
        "colab_type": "text"
      },
      "source": [
        "### State Vector"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8siXl90TVLRh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 109
        },
        "outputId": "61af3911-d2c4-4216-c877-ab37c7323ffb"
      },
      "source": [
        "q0, q1 = cirq.GridQubit.rect(1, 2)\n",
        "bell_circuit = cirq.Circuit(cirq.H(q0), cirq.CNOT(q0, q1))\n",
        "state_layer = tfq.layers.State()\n",
        "state_layer(bell_circuit)"
      ],
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow_core/python/util/deprecation.py:507: calling count_nonzero (from tensorflow.python.ops.math_ops) with axis is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "reduction_indices is deprecated, use axis instead\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.RaggedTensor [[(0.7071067690849304-1.2802768623032534e-08j), 0j, (1.3510586319685509e-15-3.0908619663705394e-08j), (0.7071067690849304+6.181723932741079e-08j)]]>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "If4MG9Ikg_G9",
        "colab_type": "text"
      },
      "source": [
        "## Hybrid Quantum-Classical Optimization"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L_6F8ho_8kEU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import cirq\n",
        "import numpy as np\n",
        "import random\n",
        "import sympy\n",
        "import tensorflow as tf\n",
        "import tensorflow_quantum as tfq"
      ],
      "execution_count": 60,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AwnuSunT8nXZ",
        "colab_type": "text"
      },
      "source": [
        "#### Step 1: Generate Quantum Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N55qzCe3SIZ-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def generate_dataset(qubit, theta_a, theta_b, num_samples):\n",
        "  \"\"\"Generate a dataset of points on `qubit` near the two given angles; labels\n",
        "  for the two clusters use a one-hot encoding.\n",
        "  \"\"\"\n",
        "  q_data = []\n",
        "  bloch = {\"a\": [[], [], []], \"b\": [[], [], []]}\n",
        "  labels = []\n",
        "  blob_size = abs(theta_a - theta_b) / 5\n",
        "  for _ in range(num_samples):\n",
        "    coin = random.random()\n",
        "    spread_x = np.random.uniform(-blob_size, blob_size)\n",
        "    spread_y = np.random.uniform(-blob_size, blob_size)\n",
        "    if coin < 0.5:\n",
        "      label = [1, 0]\n",
        "      angle = theta_a + spread_y\n",
        "      source = \"a\"\n",
        "    else:\n",
        "      label = [0, 1]\n",
        "      angle = theta_b + spread_y\n",
        "      source = \"b\"\n",
        "    labels.append(label)\n",
        "    q_data.append(cirq.Circuit(cirq.ry(-angle)(qubit), cirq.rx(-spread_x)(qubit)))\n",
        "    bloch[source][0].append(np.cos(angle))\n",
        "    bloch[source][1].append(np.sin(angle)*np.sin(spread_x))\n",
        "    bloch[source][2].append(np.sin(angle)*np.cos(spread_x))\n",
        "  return tfq.convert_to_tensor(q_data), np.array(labels), bloch\n",
        "\n",
        "#Genrate the dataset\n",
        "qubit = cirq.GridQubit(0, 0)\n",
        "theta_a = 1\n",
        "theta_b = 4\n",
        "num_samples = 200\n",
        "q_data, labels, bloch_p = generate_dataset(qubit, theta_a, theta_b, num_samples)"
      ],
      "execution_count": 61,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sWMkySMB8vOD",
        "colab_type": "text"
      },
      "source": [
        "#### Step 2 Quantum Classicl Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fdAAJl1j8hSb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#We will use a parameterized rotation about the Y axis followed by a Z-axis measurement as the quantum portion of our model.\n",
        "#For the classical portion, we will use a two-unit SoftMax which should learn to distinguish the measurement statistics of the two data sources.\n",
        "\n",
        "# Build the quantum model layer\n",
        "theta = sympy.symbols('theta')\n",
        "q_model = cirq.Circuit(cirq.ry(theta)(qubit))\n",
        "q_data_input = tf.keras.Input(shape=(), dtype=tf.dtypes.string)\n",
        "expectation = tfq.layers.PQC(q_model, cirq.Z(qubit))\n",
        "expectation_output = expectation(q_data_input)\n",
        "\n",
        "# Attach the classical SoftMax classifier\n",
        "classifier = tf.keras.layers.Dense(2, activation=tf.keras.activations.softmax)\n",
        "classifier_output = classifier(expectation_output)\n",
        "model = tf.keras.Model(inputs=q_data_input, outputs=classifier_output)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yBajpFvp-Rmb",
        "colab_type": "text"
      },
      "source": [
        "#### Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wCHTjJu19xz2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "optimizer = tf.keras.optimizers.Adam(learning_rate=0.1)\n",
        "model.compile(optimizer=optimizer,loss='categorical_crossentropy')\n",
        "tf.keras.utils.plot_model(model, show_shapes=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UFZyPjm5CLNr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "history = model.fit(x=q_data, y=labels, epochs=50)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Oah_iXGTC3Bg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "loss=history.history['loss']\n",
        "epoch=range(50)\n",
        "\n",
        "plt.plot(epoch,loss)\n",
        "plt.xlabel('epoch')\n",
        "plt.ylabel('loss')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "elh17HKr-T9F",
        "colab_type": "text"
      },
      "source": [
        "#### Testing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HS59_3_3-NYQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "test_data, _, _ = generate_dataset(qubit, theta_a, theta_b, 1)\n",
        "p = model.predict(test_data)[0]\n",
        "print(f\"prob(a)={p[0]:.4f}, prob(b)={p[1]:.4f}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5I_TmcxuFSfG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kBydx2aRY9iS",
        "colab_type": "text"
      },
      "source": [
        "## Second Example of Quantum Classical Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JOFem5ZzFN7Y",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "outputId": "6071ff4b-485a-4462-a9cf-7ceca3cd688a"
      },
      "source": [
        "# Parameters that the classical NN will feed values into.\n",
        "control_params = sympy.symbols('theta_1 theta_2 theta_3')\n",
        "\n",
        "# Create the parameterized circuit.\n",
        "qubit = cirq.GridQubit(0, 0)\n",
        "model_circuit = cirq.Circuit(\n",
        "    cirq.rz(control_params[0])(qubit),\n",
        "    cirq.ry(control_params[1])(qubit),\n",
        "    cirq.rx(control_params[2])(qubit))\n",
        "\n",
        "SVGCircuit(model_circuit)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<cirq.contrib.svg.svg.SVGCircuit at 0x7f150ede42b0>"
            ],
            "image/svg+xml": "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"435.74449218750004\" height=\"50.0\"><line x1=\"34.7588671875\" x2=\"405.74449218750004\" y1=\"25.0\" y2=\"25.0\" stroke=\"#1967d2\" stroke-width=\"1\" /><rect x=\"10.0\" y=\"5.0\" width=\"49.517734375\" height=\"40\" stroke=\"black\" fill=\"white\" stroke-width=\"0\" /><text x=\"34.7588671875\" y=\"25.0\" dominant-baseline=\"middle\" text-anchor=\"middle\" font-size=\"14px\">(0, 0): </text><rect x=\"79.517734375\" y=\"5.0\" width=\"88.37457031250001\" height=\"40\" stroke=\"black\" fill=\"white\" stroke-width=\"1\" /><text x=\"123.70501953125\" y=\"25.0\" dominant-baseline=\"middle\" text-anchor=\"middle\" font-size=\"14px\">Rz(theta_1)</text><rect x=\"187.89230468750003\" y=\"5.0\" width=\"88.54109375\" height=\"40\" stroke=\"black\" fill=\"white\" stroke-width=\"1\" /><text x=\"232.16285156250004\" y=\"25.0\" dominant-baseline=\"middle\" text-anchor=\"middle\" font-size=\"14px\">Ry(theta_2)</text><rect x=\"296.43339843750005\" y=\"5.0\" width=\"89.31109375000001\" height=\"40\" stroke=\"black\" fill=\"white\" stroke-width=\"1\" /><text x=\"341.0889453125001\" y=\"25.0\" dominant-baseline=\"middle\" text-anchor=\"middle\" font-size=\"14px\">Rx(theta_3)</text></svg>"
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TLagBxS9HUEJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# The classical neural network layers.\n",
        "controller = tf.keras.Sequential([\n",
        "    tf.keras.layers.Dense(10, activation='elu'),\n",
        "    tf.keras.layers.Dense(3)\n",
        "])"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hPp03P76HWEY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# This input is the simulated miscalibration that the model will learn to correct.\n",
        "circuits_input = tf.keras.Input(shape=(),dtype=tf.string,name='circuits_input')\n",
        "\n",
        "# Commands will be either `0` or `1`, specifying the state to set the qubit to.\n",
        "commands_input = tf.keras.Input(shape=(1,),dtype=tf.dtypes.float32,name='commands_input')"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9znTM7dTHZUS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dense_2 = controller(commands_input)\n",
        "\n",
        "# TFQ layer for classically controlled circuits.\n",
        "expectation_layer = tfq.layers.ControlledPQC(model_circuit, operators = cirq.Z(qubit))\n",
        "expectation = expectation_layer([circuits_input, dense_2])"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3HDGAyyYH36N",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# The full Keras model is built from our layers.\n",
        "model = tf.keras.Model(inputs=[circuits_input, commands_input],\n",
        "                       outputs=expectation)"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u0tLSDL6H86g",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "outputId": "f6a84fb8-a1f6-4b66-9555-422649b25f4b"
      },
      "source": [
        "tf.keras.utils.plot_model(model, show_shapes=True)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g1rUAhwiH_vR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# The command input values to the classical NN.\n",
        "commands = np.array([[0], [1]], dtype=np.float32)\n",
        "\n",
        "# The desired Z expectation value at output of quantum circuit.\n",
        "expected_outputs = np.array([[1], [-1]], dtype=np.float32)"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "URiL4YkEIB-F",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "random_rotations = np.random.uniform(0, 2 * np.pi, 3)\n",
        "noisy_preparation = cirq.Circuit(\n",
        "  cirq.rx(random_rotations[0])(qubit),\n",
        "  cirq.ry(random_rotations[1])(qubit),\n",
        "  cirq.rz(random_rotations[2])(qubit)\n",
        ")\n",
        "datapoint_circuits = tfq.convert_to_tensor([\n",
        "  noisy_preparation\n",
        "] * 2)  # Make two copied of this circuit"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cq78YBcgIG7A",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "90d359eb-ce2c-48c8-ea97-41646ce5eaa1"
      },
      "source": [
        "optimizer = tf.keras.optimizers.Adam(learning_rate=0.05)\n",
        "loss = tf.keras.losses.MeanSquaredError()\n",
        "model.compile(optimizer=optimizer, loss=loss)\n",
        "history = model.fit(x=[datapoint_circuits, commands],y=expected_outputs,epochs=30)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Train on 2 samples\n",
            "Epoch 1/30\n",
            "2/2 [==============================] - 1s 318ms/sample - loss: 0.5220\n",
            "Epoch 2/30\n",
            "2/2 [==============================] - 0s 4ms/sample - loss: 0.2536\n",
            "Epoch 3/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 0.1265\n",
            "Epoch 4/30\n",
            "2/2 [==============================] - 0s 3ms/sample - loss: 0.0566\n",
            "Epoch 5/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 0.0181\n",
            "Epoch 6/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 0.0036\n",
            "Epoch 7/30\n",
            "2/2 [==============================] - 0s 3ms/sample - loss: 3.4535e-04\n",
            "Epoch 8/30\n",
            "2/2 [==============================] - 0s 3ms/sample - loss: 1.6948e-05\n",
            "Epoch 9/30\n",
            "2/2 [==============================] - 0s 3ms/sample - loss: 4.1973e-05\n",
            "Epoch 10/30\n",
            "2/2 [==============================] - 0s 3ms/sample - loss: 5.1062e-04\n",
            "Epoch 11/30\n",
            "2/2 [==============================] - 0s 3ms/sample - loss: 0.0021\n",
            "Epoch 12/30\n",
            "2/2 [==============================] - 0s 3ms/sample - loss: 0.0050\n",
            "Epoch 13/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 0.0083\n",
            "Epoch 14/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 0.0105\n",
            "Epoch 15/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 0.0107\n",
            "Epoch 16/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 0.0091\n",
            "Epoch 17/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 0.0067\n",
            "Epoch 18/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 0.0044\n",
            "Epoch 19/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 0.0026\n",
            "Epoch 20/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 0.0014\n",
            "Epoch 21/30\n",
            "2/2 [==============================] - 0s 3ms/sample - loss: 7.4858e-04\n",
            "Epoch 22/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 4.7004e-04\n",
            "Epoch 23/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 4.7006e-04\n",
            "Epoch 24/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 6.3931e-04\n",
            "Epoch 25/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 8.2944e-04\n",
            "Epoch 26/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 8.8807e-04\n",
            "Epoch 27/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 7.6294e-04\n",
            "Epoch 28/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 5.3378e-04\n",
            "Epoch 29/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 3.1598e-04\n",
            "Epoch 30/30\n",
            "2/2 [==============================] - 0s 2ms/sample - loss: 1.6796e-04\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "evXORLXYIrWr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "outputId": "8e1430e4-54e3-4c2a-ddff-3bac8e8cd19a"
      },
      "source": [
        "plt.plot(history.history['loss'])\n",
        "plt.title(\"Learning to Control a Qubit\")\n",
        "plt.xlabel(\"Iterations\")\n",
        "plt.ylabel(\"Error in Control\")\n",
        "plt.show()"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AS3T67DFI8Qv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}