Merge pull request #832 from mhucka/mhucka-update-nbformat

Update version of nbformat & run notebooks through updated version

Author: mhucka

docs/tutorials/barren_plateaus.ipynb

@@ -86,22 +86,23 @@
     "!pip install tensorflow==2.15.0 tensorflow-quantum==0.7.3 tensorboard_plugin_profile==2.15.0"
    ]
   },
-    {
-      "cell_type": "code",
-      "execution_count": 0,
-      "metadata": {
-        "colab": {},
-        "colab_type": "code",
-        "id": "4Ql5PW-ACO0J"
-      },
-      "outputs": [],
-      "source": [
-        "# Update package resources to account for version changes.\n",
-        "import importlib, pkg_resources\n",
-        "importlib.reload(pkg_resources)"
-      ]
-    },
- {
+  {
+   "cell_type": "code",
+   "execution_count": 0,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "4Ql5PW-ACO0J"
+   },
+   "outputs": [],
+   "source": [
+    "# Update package resources to account for version changes.\n",
+    "import importlib, pkg_resources\n",
+    "\n",
+    "importlib.reload(pkg_resources)"
+   ]
+  },
+  {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
@@ -159,9 +160,11 @@
     "        qubits, depth=2)\n",
     "    return random_circuit\n",
     "\n",
+    "\n",
     "def generate_data(circuit, n_samples):\n",
     "    \"\"\"Draw n_samples samples from circuit into a tf.Tensor.\"\"\"\n",
-    "    return tf.squeeze(tfq.layers.Sample()(circuit, repetitions=n_samples).to_tensor())"
+    "    return tf.squeeze(tfq.layers.Sample()(circuit,\n",
+    "                                          repetitions=n_samples).to_tensor())"
    ]
   },
   {
@@ -270,16 +273,20 @@
     "    \"\"\"Convert tensor of bitstrings to tensor of ints.\"\"\"\n",
     "    sigs = tf.constant([1 << i for i in range(N_QUBITS)], dtype=tf.int32)\n",
     "    rounded_bits = tf.clip_by_value(tf.math.round(\n",
-    "        tf.cast(bits, dtype=tf.dtypes.float32)), clip_value_min=0, clip_value_max=1)\n",
-    "    return tf.einsum('jk,k->j', tf.cast(rounded_bits, dtype=tf.dtypes.int32), sigs)\n",
+    "        tf.cast(bits, dtype=tf.dtypes.float32)),\n",
+    "                                    clip_value_min=0,\n",
+    "                                    clip_value_max=1)\n",
+    "    return tf.einsum('jk,k->j', tf.cast(rounded_bits, dtype=tf.dtypes.int32),\n",
+    "                     sigs)\n",
+    "\n",
     "\n",
     "@tf.function\n",
     "def xeb_fid(bits):\n",
     "    \"\"\"Compute linear XEB fidelity of bitstrings.\"\"\"\n",
     "    final_probs = tf.squeeze(\n",
-    "        tf.abs(tfq.layers.State()(REFERENCE_CIRCUIT).to_tensor()) ** 2)\n",
+    "        tf.abs(tfq.layers.State()(REFERENCE_CIRCUIT).to_tensor())**2)\n",
     "    nums = bits_to_ints(bits)\n",
-    "    return (2 ** N_QUBITS) * tf.reduce_mean(tf.gather(final_probs, nums)) - 1.0"
+    "    return (2**N_QUBITS) * tf.reduce_mean(tf.gather(final_probs, nums)) - 1.0"
    ]
   },
   {
@@ -334,6 +341,8 @@
    "outputs": [],
    "source": [
     "LATENT_DIM = 100\n",
+    "\n",
+    "\n",
     "def make_generator_model():\n",
     "    \"\"\"Construct generator model.\"\"\"\n",
     "    model = tf.keras.Sequential()\n",
@@ -345,6 +354,7 @@
     "\n",
     "    return model\n",
     "\n",
+    "\n",
     "def make_discriminator_model():\n",
     "    \"\"\"Constrcut discriminator model.\"\"\"\n",
     "    model = tf.keras.Sequential()\n",
@@ -387,17 +397,21 @@
    "outputs": [],
    "source": [
     "cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)\n",
+    "\n",
+    "\n",
     "def discriminator_loss(real_output, fake_output):\n",
     "    \"\"\"Compute discriminator loss.\"\"\"\n",
     "    real_loss = cross_entropy(tf.ones_like(real_output), real_output)\n",
     "    fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)\n",
     "    total_loss = real_loss + fake_loss\n",
     "    return total_loss\n",
     "\n",
+    "\n",
     "def generator_loss(fake_output):\n",
     "    \"\"\"Compute generator loss.\"\"\"\n",
     "    return cross_entropy(tf.ones_like(fake_output), fake_output)\n",
     "\n",
+    "\n",
     "generator_optimizer = tf.keras.optimizers.Adam(1e-4)\n",
     "discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)"
    ]
@@ -410,7 +424,8 @@
    },
    "outputs": [],
    "source": [
-    "BATCH_SIZE=256\n",
+    "BATCH_SIZE = 256\n",
+    "\n",
     "\n",
     "@tf.function\n",
     "def train_step(images):\n",
@@ -425,8 +440,8 @@
     "        gen_loss = generator_loss(fake_output)\n",
     "        disc_loss = discriminator_loss(real_output, fake_output)\n",
     "\n",
-    "    gradients_of_generator = gen_tape.gradient(\n",
-    "        gen_loss, generator.trainable_variables)\n",
+    "    gradients_of_generator = gen_tape.gradient(gen_loss,\n",
+    "                                               generator.trainable_variables)\n",
     "    gradients_of_discriminator = disc_tape.gradient(\n",
     "        disc_loss, discriminator.trainable_variables)\n",
     "\n",
@@ -480,29 +495,37 @@
     "def train(dataset, epochs, start_epoch=1):\n",
     "    \"\"\"Launch full training run for the given number of epochs.\"\"\"\n",
     "    # Log original training distribution.\n",
-    "    tf.summary.histogram('Training Distribution', data=bits_to_ints(dataset), step=0)\n",
+    "    tf.summary.histogram('Training Distribution',\n",
+    "                         data=bits_to_ints(dataset),\n",
+    "                         step=0)\n",
     "\n",
-    "    batched_data = tf.data.Dataset.from_tensor_slices(dataset).shuffle(N_SAMPLES).batch(512)\n",
+    "    batched_data = tf.data.Dataset.from_tensor_slices(dataset).shuffle(\n",
+    "        N_SAMPLES).batch(512)\n",
     "    t = time.time()\n",
     "    for epoch in range(start_epoch, start_epoch + epochs):\n",
     "        for i, image_batch in enumerate(batched_data):\n",
     "            # Log batch-wise loss.\n",
     "            gl, dl = train_step(image_batch)\n",
-    "            tf.summary.scalar(\n",
-    "                'Generator loss', data=gl, step=epoch * len(batched_data) + i)\n",
-    "            tf.summary.scalar(\n",
-    "                'Discriminator loss', data=dl, step=epoch * len(batched_data) + i)\n",
+    "            tf.summary.scalar('Generator loss',\n",
+    "                              data=gl,\n",
+    "                              step=epoch * len(batched_data) + i)\n",
+    "            tf.summary.scalar('Discriminator loss',\n",
+    "                              data=dl,\n",
+    "                              step=epoch * len(batched_data) + i)\n",
     "\n",
     "        # Log full dataset XEB Fidelity and generated distribution.\n",
     "        generated_samples = generator(tf.random.normal([N_SAMPLES, 100]))\n",
-    "        tf.summary.scalar(\n",
-    "        'Generator XEB Fidelity Estimate', data=xeb_fid(generated_samples), step=epoch)\n",
-    "        tf.summary.histogram(\n",
-    "        'Generator distribution', data=bits_to_ints(generated_samples), step=epoch)\n",
+    "        tf.summary.scalar('Generator XEB Fidelity Estimate',\n",
+    "                          data=xeb_fid(generated_samples),\n",
+    "                          step=epoch)\n",
+    "        tf.summary.histogram('Generator distribution',\n",
+    "                             data=bits_to_ints(generated_samples),\n",
+    "                             step=epoch)\n",
     "        # Log new samples drawn from this particular random circuit.\n",
     "        random_new_distribution = generate_data(REFERENCE_CIRCUIT, N_SAMPLES)\n",
-    "        tf.summary.histogram(\n",
-    "        'New round of True samples', data=bits_to_ints(random_new_distribution), step=epoch)\n",
+    "        tf.summary.histogram('New round of True samples',\n",
+    "                             data=bits_to_ints(random_new_distribution),\n",
+    "                             step=epoch)\n",
     "\n",
     "        if epoch % 10 == 0:\n",
     "            print('Epoch {}, took {}(s)'.format(epoch, time.time() - t))\n",

docs/tutorials/gradients.ipynb

@@ -2,7 +2,7 @@ cirq-core==1.3.0
 cirq-google==1.3.0
 sympy==1.12
 numpy==1.24.2  # TensorFlow can detect if it was built against other versions.
-nbformat==4.4.0
+nbformat==5.1.3
 pylint==2.4.4
 yapf==0.40.2
 tensorflow==2.15.0