C2_W1_Lab_1_basic-tensors.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Tensors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this ungraded lab, you will try some of the basic operations you can perform on tensors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jqev488WJ9-R"
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    # %tensorflow_version only exists in Colab.\n",
    "    %tensorflow_version 2.x\n",
    "except Exception:\n",
    "    pass\n",
    "\n",
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sIIXMZboUw-P"
   },
   "source": [
    "## Exercise on basic Tensor operations\n",
    "\n",
    "Lets create a single dimension numpy array on which you can perform some operation. You'll make an array of size 25, holding values from 0 to 24."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GkBZyS8hKNXX"
   },
   "outputs": [],
   "source": [
    "# Create a 1D uint8 NumPy array comprising of first 25 natural numbers\n",
    "x = np.arange(0, 25)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have your 1-D array, next you'll change that array into a `tensor`. After running the code block below, take a moment to inspect the information of your tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MYdVyiSoLPgO"
   },
   "outputs": [],
   "source": [
    "# Convert NumPy array to Tensor using `tf.constant`\n",
    "x = tf.constant(x)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the first operation to be performed, you'll square (element-wise) all the values in the tensor `x`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "W6BTwNJCLjV8"
   },
   "outputs": [],
   "source": [
    "# Square the input tensor x\n",
    "x = tf.square(x)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One feature of tensors is that they can be reshaped. When reshpaing, make sure you consider dimensions that will include all of the values of the tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7nzBSX8-L0Xt"
   },
   "outputs": [],
   "source": [
    "# Reshape tensor x into a 5 x 5 matrix. \n",
    "x = tf.reshape(x, (5, 5))\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that you'll get an error message if you choose a shape that cannot be exactly filled with the values of the given tensor.  \n",
    "* Run the cell below and look at the error message\n",
    "* Try to change the tuple that is passed to `shape` to avoid an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try this and look at the error\n",
    "# Try to change the input to `shape` to avoid an error\n",
    "tmp = tf.constant([1,2,3,4])\n",
    "tf.reshape(tmp, shape=(2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like reshaping, you can also change the data type of the values within the tensor. Run the cell below to change the data type from `int` to `float`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VoT-jiAIL8x5"
   },
   "outputs": [],
   "source": [
    "# Cast tensor x into float32. Notice the change in the dtype.\n",
    "x = tf.cast(x, tf.float32)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, you'll create a single value float tensor by the help of which you'll see `broadcasting` in action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's define a constant and see how broadcasting works in the following cell.\n",
    "y = tf.constant(2, dtype=tf.float32)\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiply the tensors `x` and `y` together, and notice how multiplication was done and its result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ivepGtD5MKP5"
   },
   "outputs": [],
   "source": [
    "# Multiply tensor `x` and `y`. `y` is multiplied to each element of x.\n",
    "result = tf.multiply(x, y)\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Re-Initialize `y` to a tensor having more values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8wzZ5NcMMPzD"
   },
   "outputs": [],
   "source": [
    "# Now let's define an array that matches the number of row elements in the `x` array.\n",
    "y = tf.constant([1, 2, 3, 4, 5], dtype=tf.float32)\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's see first the contents of `x` again.\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add the tensors `x` and `y` together, and notice how addition was done and its result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BVlntdYnMboh"
   },
   "outputs": [],
   "source": [
    "# Add tensor `x` and `y`. `y` is added element wise to each row of `x`.\n",
    "result = x + y\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The shape parameter for tf.constant\n",
    "\n",
    "When using `tf.constant()`, you can pass in a 1D array (a vector) and set the `shape` parameter to turn this vector into a multi-dimensional array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.constant([1,2,3,4], shape=(2,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The shape parameter for tf.Variable\n",
    "\n",
    "Note, however, that for `tf.Variable()`, the shape of the tensor is derived from the shape given by the input array.  Setting `shape` to something other than `None` will not reshape a 1D array into a multi-dimensional array, and will give a `ValueError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    # This will produce a ValueError\n",
    "    tf.Variable([1,2,3,4], shape=(2,2))\n",
    "except ValueError as v:\n",
    "    # See what the ValueError says\n",
    "    print(v)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "basictensors.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
}