C2_W1_Lab_2_gradient-tape-basics (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gradient Tape Basics\n",
    "\n",
    "In this ungraded lab, you'll get familiar with Tensorflow's built in API called Gradient Tape which helps in performing automatic differentiation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uQe_MWjNPQkR"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise on basics of Gradient Tape\n",
    "\n",
    "Let's explore how you can use [tf.GradientTape()](https://www.tensorflow.org/api_docs/python/tf/GradientTape) to do automatic differentiation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "colab_type": "code",
    "id": "57Vnn9iIPNh9",
    "outputId": "543fce75-1adc-447c-b70b-872e8f8c9841"
   },
   "outputs": [],
   "source": [
    "# Define a 2x2 array of 1's\n",
    "x = tf.ones((2,2))\n",
    "\n",
    "with tf.GradientTape() as t:\n",
    "    # Record the actions performed on tensor x with `watch`\n",
    "    t.watch(x) \n",
    "\n",
    "    # Define y as the sum of the elements in x\n",
    "    y =  tf.reduce_sum(x)\n",
    "\n",
    "    # Let z be the square of y\n",
    "    z = tf.square(y) \n",
    "\n",
    "# Get the derivative of z wrt the original input tensor x\n",
    "dz_dx = t.gradient(z, x)\n",
    "\n",
    "# Print our result\n",
    "print(dz_dx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gradient tape expires after one use, by default\n",
    "\n",
    "If you want to compute multiple gradients, note that by default, GradientTape is not persistent (`persistent=False`).  This means that the GradientTape will expire after you use it to calculate a gradient.\n",
    "\n",
    "To see this, set up gradient tape as usual and calculate a gradient, so that the gradient tape will be 'expired'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.constant(3.0)\n",
    "\n",
    "# Notice that persistent is False by default\n",
    "with tf.GradientTape() as t:\n",
    "    t.watch(x)\n",
    "    \n",
    "    # y = x^2\n",
    "    y = x * x\n",
    "    \n",
    "    # z = y^2\n",
    "    z = y * y\n",
    "\n",
    "# Compute dz/dx. 4 * x^3 at x = 3 --> 108.0\n",
    "dz_dx = t.gradient(z, x)\n",
    "print(dz_dx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Gradient tape has expired\n",
    "\n",
    "See what happens if you try to calculate another gradient after you've already used gradient tape once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If you try to compute dy/dx after the gradient tape has expired:\n",
    "try:\n",
    "    dy_dx = t.gradient(y, x)  # 6.0\n",
    "    print(dy_dx)\n",
    "except RuntimeError as e:\n",
    "    print(\"The error message you get is:\")\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make the gradient tape persistent\n",
    "To make sure that the gradient tape can be used multiple times, set `persistent=True` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "P12ExatAPqn6",
    "outputId": "65d8c2ca-b49d-4b91-d2d5-97153daf5d19"
   },
   "outputs": [],
   "source": [
    "x = tf.constant(3.0)\n",
    "\n",
    "# Set persistent=True so that you can reuse the tape\n",
    "with tf.GradientTape(persistent=True) as t:\n",
    "    t.watch(x)\n",
    "    \n",
    "    # y = x^2\n",
    "    y = x * x\n",
    "    \n",
    "    # z = y^2\n",
    "    z = y * y\n",
    "\n",
    "# Compute dz/dx. 4 * x^3 at x = 3 --> 108.0\n",
    "dz_dx = t.gradient(z, x)\n",
    "print(dz_dx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now that it's persistent, you can still reuse this tape!\n",
    "\n",
    "Try calculating a second gradient on this persistent tape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can still compute dy/dx because of the persistent flag.\n",
    "dy_dx = t.gradient(y, x)  # 6.0\n",
    "print(dy_dx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! It still works!  Delete the tape variable `t` once you no longer need it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Drop the reference to the tape\n",
    "del t  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested Gradient tapes\n",
    "Now let's try computing a higher order derivative by nesting the `GradientTapes:`\n",
    "\n",
    "#### Acceptable indentation of the first gradient calculation\n",
    "Keep in mind that you'll want to make sure that the first gradient calculation of `dy_dx` should occur at least inside the outer `with` block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "UxNLeFLlP4qU",
    "outputId": "5f96770a-f0a3-47e5-dd8d-3e0b3074deeb"
   },
   "outputs": [],
   "source": [
    "x = tf.Variable(1.0)\n",
    "\n",
    "with tf.GradientTape() as tape_2:\n",
    "    with tf.GradientTape() as tape_1:\n",
    "        y = x * x * x\n",
    "    \n",
    "    # The first gradient calculation should occur at leaset\n",
    "    # within the outer with block\n",
    "    dy_dx = tape_1.gradient(y, x)\n",
    "d2y_dx2 = tape_2.gradient(dy_dx, x)\n",
    "\n",
    "print(dy_dx)\n",
    "print(d2y_dx2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first gradient calculation can also be inside the inner with block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.Variable(1.0)\n",
    "\n",
    "with tf.GradientTape() as tape_2:\n",
    "    with tf.GradientTape() as tape_1:\n",
    "        y = x * x * x\n",
    "    \n",
    "        # The first gradient calculation can also be within the inner with block\n",
    "        dy_dx = tape_1.gradient(y, x)\n",
    "d2y_dx2 = tape_2.gradient(dy_dx, x)\n",
    "\n",
    "print(dy_dx)\n",
    "print(d2y_dx2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Where not to indent the first gradient calculation\n",
    "If the first gradient calculation is OUTSIDE of the outer `with` block, it won't persist for the second gradient calculation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.Variable(1.0)\n",
    "\n",
    "with tf.GradientTape() as tape_2:\n",
    "    with tf.GradientTape() as tape_1:\n",
    "        y = x * x * x\n",
    "\n",
    "# The first gradient call is outside the outer with block\n",
    "# so the tape will expire after this\n",
    "dy_dx = tape_1.gradient(y, x)\n",
    "\n",
    "# The tape is now expired and the gradient output will be `None`\n",
    "d2y_dx2 = tape_2.gradient(dy_dx, x)\n",
    "\n",
    "print(dy_dx)\n",
    "print(d2y_dx2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the `d2y_dx2` calculation is now `None`.  The tape has expired.  Also note that this still won't work even if you set persistent=True for both gradient tapes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.Variable(1.0)\n",
    "\n",
    "# Setting persistent=True still won't work\n",
    "with tf.GradientTape(persistent=True) as tape_2:\n",
    "    # Setting persistent=True still won't work\n",
    "    with tf.GradientTape(persistent=True) as tape_1:\n",
    "        y = x * x * x\n",
    "\n",
    "# The first gradient call is outside the outer with block\n",
    "# so the tape will expire after this\n",
    "dy_dx = tape_1.gradient(y, x)\n",
    "\n",
    "# the output will be `None`\n",
    "d2y_dx2 = tape_2.gradient(dy_dx, x)\n",
    "\n",
    "print(dy_dx)\n",
    "print(d2y_dx2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Proper indentation for the second gradient calculation\n",
    "\n",
    "The second gradient calculation `d2y_dx2` can be indented as much as the first calculation of `dy_dx` but not more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.Variable(1.0)\n",
    "\n",
    "with tf.GradientTape() as tape_2:\n",
    "    with tf.GradientTape() as tape_1:\n",
    "        y = x * x * x\n",
    "\n",
    "        dy_dx = tape_1.gradient(y, x)\n",
    "        \n",
    "        # this is acceptable\n",
    "        d2y_dx2 = tape_2.gradient(dy_dx, x)\n",
    "\n",
    "print(dy_dx)\n",
    "print(d2y_dx2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is also acceptable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.Variable(1.0)\n",
    "\n",
    "with tf.GradientTape() as tape_2:\n",
    "    with tf.GradientTape() as tape_1:\n",
    "        y = x * x * x\n",
    "\n",
    "        dy_dx = tape_1.gradient(y, x)\n",
    "        \n",
    "    # this is also acceptable\n",
    "    d2y_dx2 = tape_2.gradient(dy_dx, x)\n",
    "\n",
    "print(dy_dx)\n",
    "print(d2y_dx2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is also acceptable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.Variable(1.0)\n",
    "\n",
    "with tf.GradientTape() as tape_2:\n",
    "    with tf.GradientTape() as tape_1:\n",
    "        y = x * x * x\n",
    "\n",
    "        dy_dx = tape_1.gradient(y, x)\n",
    "        \n",
    "# this is also acceptable\n",
    "d2y_dx2 = tape_2.gradient(dy_dx, x)\n",
    "\n",
    "print(dy_dx)\n",
    "print(d2y_dx2)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "GradientTapeBasics.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}