diff --git a/docs/tutorials/quantum_advantage_in_learning_from_experiments.ipynb b/docs/tutorials/quantum_advantage_in_learning_from_experiments.ipynb new file mode 100644 index 000000000..a43774515 --- /dev/null +++ b/docs/tutorials/quantum_advantage_in_learning_from_experiments.ipynb @@ -0,0 +1,795 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "xLOXFOT5Q40E" + }, + "source": [ + "##### Copyright 2020 The TensorFlow Authors." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "colab": {}, + "colab_type": "code", + "id": "iiQkM5ZgQ8r2" + }, + "outputs": [], + "source": [ + "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# https://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "j6331ZSsQGY3" + }, + "source": [ + "# Quantum advantage in learning from experiments" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "i9Jcnb8bQQyd" + }, + "source": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " View on TensorFlow.org\n", + " \n", + " Run in Google Colab\n", + " \n", + " View source on GitHub\n", + " \n", + " Download notebook\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "6tYn2HaAUgH0" + }, + "source": [ + "This tutorial shows the experiments of Quantum advantage in learning from experiments." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "sPZoNKvpUaqa" + }, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "TorxE5tnkvb2" + }, + "outputs": [], + "source": [ + "!pip install tensorflow==2.7.0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "F1L8h1YKUvIO" + }, + "source": [ + "Now import TensorFlow and the module dependencies:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "enZ300Bflq80" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import cirq\n", + "from cirq.contrib.svg import SVGCircuit\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from tensorflow_quantum.core.ops.math_ops import simulate_mps\n", + "from tensorflow_quantum.python import util" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Creating the circuits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We first define the circuit we are going to use to generate samples. We first define the rotations for the Pauli Measurements." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def inv_z_basis_gate(circuit, pauli, qubit):\n", + " if pauli == \"I\" or pauli == \"Z\":\n", + " circuit += cirq.I(qubit)\n", + " elif pauli == \"X\":\n", + " circuit += cirq.H(qubit)\n", + " elif pauli == \"Y\":\n", + " # S^dag H to get to computational, H S to go back. \n", + " circuit += cirq.ZPowGate(exponent=0.5)(qubit)\n", + " circuit += cirq.XPowGate(exponent=0.5)(qubit)\n", + " circuit += cirq.ZPowGate(exponent=1.0)(qubit)\n", + " else:\n", + " raise ValueError(\"Invalid Pauli.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The tutorial compares the use of Bell pairs versus not using them (and thus using the previously discovered classical shadows). The point of the paper is that the proposed approach of using Bell pairs is more accurate." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def un_bell_pair_block(qubits):\n", + " return [cirq.CNOT(qubits[0], qubits[1]), cirq.H(qubits[0])]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We then build the circuit. For simplicity, in case we use classical shadows, we only have half the circuit." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def build_circuit(qubit_pairs, pauli, classical_shadows):\n", + " a_qubits = [pair[0] for pair in qubit_pairs]\n", + " b_qubits = [pair[1] for pair in qubit_pairs]\n", + " all_qubits = np.concatenate(qubit_pairs)\n", + "\n", + " ret_circuit = cirq.Circuit()\n", + "\n", + " # Add basis turns a and b.\n", + " for q, p in zip(a_qubits, pauli):\n", + " inv_z_basis_gate(ret_circuit, p, q)\n", + " if not classical_shadows:\n", + " for q, p in zip(b_qubits, pauli):\n", + " inv_z_basis_gate(ret_circuit, p, q)\n", + "\n", + " if classical_shadows:\n", + " # Add measurements.\n", + " for i, qubit in enumerate(a_qubits):\n", + " ret_circuit += cirq.measure(qubit, key=f\"q{i}\")\n", + " else: # not classical_shadows\n", + " # Add un-bell pair.\n", + " ret_circuit += [un_bell_pair_block(pair) for pair in qubit_pairs]\n", + "\n", + " # Add measurements.\n", + " for i, qubit in enumerate(all_qubits):\n", + " ret_circuit += cirq.measure(qubit, key=f\"q{i}\")\n", + "\n", + " return ret_circuit\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us now show some examples of circuits for various Paulis and for both classical shadows and Bell measurements." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "findfont: Font family ['Arial'] not found. Falling back to DejaVu Sans.\n" + ] + }, + { + "data": { + "image/svg+xml": [ + "q0: q1: IIXHMM" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "_example_qubits = [(cirq.NamedQubit('q0'), cirq.NamedQubit('q1'))]\n", + "\n", + "SVGCircuit(build_circuit(_example_qubits, 'I', False))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "q0: q1: HHXHMM" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SVGCircuit(build_circuit(_example_qubits, 'X', False))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "q0: q1: SSX^0.5X^0.5ZZXHMM" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SVGCircuit(build_circuit(_example_qubits, 'Y', False))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In case we do use classical shadows, we only see a single qubit:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "q0: SX^0.5ZM" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SVGCircuit(build_circuit(_example_qubits, 'Y', True))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We then generate the sweeping parameters, following section A.2.a of the paper." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def create_randomized_sweep(hidden_p, system_pairs, rand_source):\n", + " last_i = 0\n", + " for i, pauli in enumerate(hidden_p):\n", + " if pauli != \"I\":\n", + " last_i = i\n", + "\n", + " sign_p = rand_source.choice([1, -1])\n", + "\n", + " current_sweep = cirq.Circuit()\n", + " for twocopy in [0, 1]:\n", + " parity = sign_p * rand_source.choice([1, -1], p=[0.95, 0.05])\n", + " for i, pauli in enumerate(hidden_p):\n", + " current_flip = rand_source.choice([0, 1])\n", + " if pauli != \"I\":\n", + " if last_i == i:\n", + " v = 1 if parity == -1 else 0\n", + " current_flip = v\n", + " elif current_flip == 1:\n", + " parity *= -1\n", + " if current_flip == 1:\n", + " current_sweep.append(cirq.X(system_pairs[i][twocopy]))\n", + "\n", + " return current_sweep" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us look at an example of a rotation circuit." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "q0: q1: XX" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SVGCircuit(create_randomized_sweep('X', _example_qubits, np.random.RandomState(19950610)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Create the training data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We first define some constants. Some numbers are chosen to be prime for ease of interpreting the dimenstions. Also, we define the qubits to use. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "rand_source = np.random.RandomState(20160913)\n", + "n_paulis = 3\n", + "n = 4\n", + "n_shots = 11\n", + "n_repeats = 13\n", + "classical_shadows = False\n", + "\n", + "system_pairs = [(cirq.GridQubit(i, 0), cirq.GridQubit(i, 1)) for i in range(n)]\n", + "simulator = cirq.Simulator()\n", + "\n", + "all_results = []\n", + "\n", + "if classical_shadows:\n", + " qubit_order = [f\"q{i}\" for i in range(n)]\n", + "else: # not classical_shadows\n", + " qubit_order = [f\"q{i}\" for i in range(2 * n)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We define a helper function to convert an integer to a Pauli. The reason is we want to guarantee unique Paulis." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def integer_to_pauli(n, pauli_num):\n", + " pauli = ''\n", + " for _ in range(n):\n", + " base4 = pauli_num % 4\n", + " if base4 == 0:\n", + " pauli += 'I'\n", + " elif base4 == 1:\n", + " pauli += 'X'\n", + " elif base4 == 3:\n", + " pauli += 'Y'\n", + " else:\n", + " pauli += 'Z'\n", + " pauli_num = (pauli_num - base4) // 4\n", + " return pauli" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We then generate all the Paulis with multiple shots." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3, 11, 13, 8)\n" + ] + } + ], + "source": [ + "paulis = []\n", + "for pauli_num in rand_source.choice(range(4**n), n_paulis, replace=False):\n", + " pauli = integer_to_pauli(n, pauli_num)\n", + " paulis.append(pauli)\n", + "\n", + " base_circuit = build_circuit(system_pairs,\n", + " pauli,\n", + " classical_shadows=classical_shadows)\n", + "\n", + " results_for_pauli = []\n", + "\n", + " # Create randomized flippings. These flippings will contain values of 1,0.\n", + " # which will turn the X gates on or off.\n", + " for _ in range(n_shots):\n", + " rot_circuit = create_randomized_sweep(pauli, system_pairs, rand_source)\n", + " \n", + " results = simulate_mps.mps_1d_sample(\n", + " programs=util.convert_to_tensor(\n", + " [rot_circuit + base_circuit]),\n", + " symbol_names=[], symbol_values=[[]],\n", + " num_samples=[n_repeats],\n", + " bond_dim=16)\n", + "\n", + " results_for_pauli.append(np.squeeze(results.numpy()))\n", + " all_results.append(results_for_pauli)\n", + "\n", + "all_results = np.array(all_results)\n", + "\n", + "print(all_results.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Create the neural network" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we create the model that encodes the measurements. The first model is a recurrent model (GRU) that encodes along the measurements." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "class InnerLayer(tf.keras.Model):\n", + "\n", + " def __init__(self, n_shots, num_qubits):\n", + " super(InnerLayer, self).__init__(name='inner')\n", + " self.n_shots = n_shots\n", + " self.num_qubits = num_qubits\n", + " self.gru1 = tf.keras.layers.GRU(4,\n", + " go_backwards=False,\n", + " return_sequences=True)\n", + " self.gru2 = tf.keras.layers.GRU(4,\n", + " go_backwards=True,\n", + " return_sequences=True)\n", + " self.gru3 = tf.keras.layers.GRU(4,\n", + " go_backwards=False,\n", + " return_sequences=False)\n", + "\n", + " def call(self, x):\n", + " x = tf.expand_dims(tf.reshape(x, (-1, self.num_qubits)), -1)\n", + " x = self.gru1(x)\n", + " x = self.gru2(x)\n", + " x = self.gru3(x)\n", + " x = tf.reshape(x, (-1, self.n_shots, 4))\n", + " return x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we define an intermediate model that summarizes the output of the recurrent model." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "class IntermediateLayer(tf.keras.Model):\n", + "\n", + " def __init__(self):\n", + " super(IntermediateLayer, self).__init__(name='intermediate')\n", + "\n", + " def build(self, input_shape):\n", + " self.kernel = self.add_weight(\"kernel\", shape=[int(input_shape[2]), 8])\n", + "\n", + " def call(self, x):\n", + " x = tf.math.reduce_mean(x, axis=1)\n", + " x = tf.matmul(x, self.kernel)\n", + " return x\n", + "\n", + "\n", + "model = tf.keras.Sequential()\n", + "model.add(InnerLayer(n_shots, len(qubit_order)))\n", + "model.add(IntermediateLayer())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, we define an outer layer whose role is to compare the two outputs and create a softmax output of dimension 2 predicting whether the two Paulis are indentical or not." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "class OuterLayer(tf.keras.Model):\n", + "\n", + " def __init__(self):\n", + " super(OuterLayer, self).__init__(name='')\n", + "\n", + " def call(self, x):\n", + " x = tf.norm(x[1] - x[0], ord=2, axis=1)\n", + " x = tf.stack([x, tf.ones(tf.shape(x))], axis=1)\n", + " x = tf.nn.softmax(x)\n", + " return x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we define the conjoined model that compares outputs. It uses two inputs, fed through the individual models, and then we " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "input_1 = tf.keras.Input((\n", + " n_shots,\n", + " len(qubit_order),\n", + "))\n", + "input_2 = tf.keras.Input((\n", + " n_shots,\n", + " len(qubit_order),\n", + "))\n", + "\n", + "encoded_1 = model(input_1)\n", + "encoded_2 = model(input_2)\n", + "\n", + "\n", + "predictor = OuterLayer()\n", + "prediction = predictor([encoded_1, encoded_2])\n", + "\n", + "conjoined_net = tf.keras.Model(inputs=[input_1, input_2], outputs=prediction)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Train the model" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = tf.keras.optimizers.Adam(learning_rate=0.01)\n", + "loss = tf.keras.losses.BinaryCrossentropy(from_logits=False)\n", + "\n", + "conjoined_net.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])\n", + "\n", + "\n", + "def _sample_different(max_val, ref):\n", + " ret = ref\n", + " while ret == ref:\n", + " ret = rand_source.choice(max_val)\n", + " return ret\n", + "\n", + "\n", + "x1 = []\n", + "x2 = []\n", + "y = []\n", + "for pauli_idx in range(n_paulis):\n", + " # Same Pauli\n", + " for i in range(n_repeats):\n", + " j = _sample_different(n_repeats, i)\n", + "\n", + " x1.append(all_results[pauli_idx, :, i, :].astype(float))\n", + " x2.append(all_results[pauli_idx, :, j, :].astype(float))\n", + " y.append([1.0, 0.0])\n", + "\n", + " # Different Pauli\n", + " for i in range(n_repeats):\n", + " other_pauli_idx = _sample_different(n_paulis, pauli_idx)\n", + " j = rand_source.choice(n_repeats)\n", + " x1.append(all_results[pauli_idx, :, i, :].astype(float))\n", + " x2.append(all_results[other_pauli_idx, :, j, :].astype(float))\n", + " y.append([0.0, 1.0])\n", + "\n", + "x1 = np.stack(x1)\n", + "x2 = np.stack(x2)\n", + "y = np.stack(y)\n", + "\n", + "history = conjoined_net.fit(x=[x1, x2],\n", + " y=y,\n", + " epochs=500,\n", + " batch_size=(2 * n_paulis),\n", + " verbose=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the results." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(history.history['accuracy'], 'b')\n", + "plt.ylabel('accuracy')\n", + "plt.show()\n", + "\n", + "plt.plot(history.history['loss'], 'r')\n", + "plt.ylabel('loss')\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "quantum_advantage_in_learning_from_experiments.ipynb", + "private_outputs": true, + "provenance": [], + "toc_visible": true + }, + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}