00_tensorflow_fundamentals.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "00_tensorflow_fundamentals.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pjR5NFnD06rO"
      },
      "source": [
        "# In this notebook , we're going to cover some of the most fundamental concepts of tensors using Tensorflow\n",
        "More Specifically , we're going to cover:\n",
        "\n",
        " - Introduction to tensors\n",
        " - Getting information from tensors\n",
        " - Manipulating tensors\n",
        " - Tensors and numpy\n",
        " - using @tf.function ( a way to speed up your regular python function)\n",
        " - using GPU with Tensorflow ( o TPU)\n",
        " - Exercise to try for yourself!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gvYteim51ZQO"
      },
      "source": [
        "# Introduction to Tensors"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qJJxNso10y88",
        "outputId": "bbaafba8-b2f4-4242-8a0c-682ca8c155c2"
      },
      "source": [
        "# import Tensorflow\n",
        "import tensorflow as tf\n",
        "print(tf.__version__)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.4.1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0FxuegKY1lNl",
        "outputId": "5a1f6e68-b443-445c-e34f-27c2c789600b"
      },
      "source": [
        "# Creating tensors with tf.constant()\n",
        "scaler = tf.constant(7)\n",
        "scaler"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int32, numpy=7>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cbF41c832WkL",
        "outputId": "1076fbb8-c987-49f7-b2c3-f7697e1eafcd"
      },
      "source": [
        "# Check the number of dimension of a tensor\n",
        "scaler.ndim"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4bE5yKD-22P7",
        "outputId": "5af2ba6d-0a31-43c8-9fca-fd4d7808e569"
      },
      "source": [
        "# Create a Vector\n",
        "vector = tf.constant([10,10])\n",
        "vector"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([10, 10], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IZX9TzMv2_NR",
        "outputId": "fc4f2c4c-5b2d-4d6d-d7a3-9e67cab4fb2c"
      },
      "source": [
        "# Check the dimension of our vector\n",
        "vector.ndim"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-VTfYqI73Y0q",
        "outputId": "011515ab-a97f-46fb-c519-951bcb668499"
      },
      "source": [
        "# Create  a matrix\n",
        "matrix = tf.constant([[10 ,7],\n",
        "                     [7 , 10]])\n",
        "matrix"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[10,  7],\n",
              "       [ 7, 10]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0KjCfS5w3f7O",
        "outputId": "12c26495-80a7-42a9-ed1a-d465ccd13c2a"
      },
      "source": [
        "matrix.ndim"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UieX7qLj3mI3"
      },
      "source": [
        "# Create another matrix\n",
        "another_matrix = tf.constant([[10.,  7.],\n",
        "                              [3., 2.],\n",
        "                              [8., 9.]] , dtype = tf.float16)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MA6YiyPC3702",
        "outputId": "30428171-fac1-4878-f174-136fe8bad6be"
      },
      "source": [
        "another_matrix"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=float16, numpy=\n",
              "array([[10.,  7.],\n",
              "       [ 3.,  2.],\n",
              "       [ 8.,  9.]], dtype=float16)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zbhE2VDQ4NU8",
        "outputId": "ee60a2d7-e112-47f7-aba9-47e97c74dd96"
      },
      "source": [
        "another_matrix.ndim"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gHAMRBBh4QK9",
        "outputId": "5a68dfa2-3eb1-4143-dda3-c98b44c4a779"
      },
      "source": [
        "# Let's create a tensor\n",
        "\n",
        "tensor = tf.constant([[[1, 2, 3],\n",
        "                       [4, 5, 6]],\n",
        "                      [[7, 8, 9],\n",
        "                       [10, 11, 12]],\n",
        "                      [[13, 14, 15],\n",
        "                       [16, 17, 18]]])\n",
        "\n",
        "tensor"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2, 3), dtype=int32, numpy=\n",
              "array([[[ 1,  2,  3],\n",
              "        [ 4,  5,  6]],\n",
              "\n",
              "       [[ 7,  8,  9],\n",
              "        [10, 11, 12]],\n",
              "\n",
              "       [[13, 14, 15],\n",
              "        [16, 17, 18]]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "23eo4UL47TNZ",
        "outputId": "00b8f0c0-2498-493e-cd51-7daa1142b9f5"
      },
      "source": [
        "tensor.ndim"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X52YTgOc8ocv"
      },
      "source": [
        "This is known as a rank 3 tensor (3-dimensions), however a tensor can have an arbitrary (unlimited) amount of dimensions.\n",
        "\n",
        "For example, you might turn a series of images into tensors with shape (224, 224, 3, 32), where:\n",
        "\n",
        " - 224, 224 (the first 2 dimensions) are the height and width of the images in pixels.\n",
        " - 3 is the number of colour channels of the image (red, green blue).\n",
        " - 32 is the batch size (the number of images a neural network sees at any one time).\n",
        "\n",
        "All of the above variables we've created are actually tensors. But you may also hear them referred to as their different names (the ones we gave them):\n",
        "\n",
        " - scalar: a single number.\n",
        " - vector: a number with direction (e.g. wind speed with direction).\n",
        " - matrix: a 2-dimensional array of numbers.\n",
        " - tensor: an n-dimensional array of numbers (where n can be any number, a 0-dimension tensor is a scalar, a 1-dimension tensor is a vector).\n",
        " \n",
        "To add to the confusion, the terms matrix and tensor are often used interchangably.\n",
        "\n",
        "Going forward since we're using TensorFlow, everything we refer to and use will be tensors."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "14HAL5_084HN"
      },
      "source": [
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o7FO8p9M9ANa"
      },
      "source": [
        "## Creating Tensors with tf.Variable()\n",
        "You can also (although you likely rarely will, because often, when working with data, tensors are created for you automatically) create tensors using tf.Variable().\n",
        "\n",
        "The difference between tf.Variable() and tf.constant() is tensors created with tf.constant() are immutable (can't be changed, can only be used to create a new tensor), where as, tensors created with tf.Variable() are mutable (can be changed)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hD9HJMe983oP",
        "outputId": "e9176c45-57ed-4c28-8c0d-3aba83ef472f"
      },
      "source": [
        "# Create the same tensor with tf.Variable() and tf.constant()\n",
        "changeble_tensor  =tf.Variable([10 , 7])\n",
        "unchangeble_tensor = tf.constant([10 , 7])\n",
        "changeble_tensor  , unchangeble_tensor"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Variable 'Variable:0' shape=(2,) dtype=int32, numpy=array([10,  7], dtype=int32)>,\n",
              " <tf.Tensor: shape=(2,), dtype=int32, numpy=array([10,  7], dtype=int32)>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qfcm_vm19ZrF"
      },
      "source": [
        "Now let's try to change one of the elements of the changable tensor."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rj1WPi9U8pT-",
        "outputId": "265ff2d0-4eaa-4010-c0f5-8d4b733db053"
      },
      "source": [
        "changeble_tensor[0].assign(7)\n",
        "changeble_tensor"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Variable 'Variable:0' shape=(2,) dtype=int32, numpy=array([7, 7], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NcADXMMX9niD"
      },
      "source": [
        "Now let's try to change a value in a tf.constant() tensor."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 195
        },
        "id": "hsT2kWiH9kgX",
        "outputId": "bb2de246-07ec-4001-eaf1-f6c4f5784fe0"
      },
      "source": [
        "# Will error (can't change tf.constant())\n",
        "unchangeable_tensor[0].assign(7)\n",
        "unchangleable_tensor"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-15-3947b974feb9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Will error (can't change tf.constant())\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0munchangeable_tensor\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0massign\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0munchangleable_tensor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'unchangeable_tensor' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-I_KRqiQ9ty_"
      },
      "source": [
        "Which one should you use? tf.constant() or tf.Variable()?\n",
        "\n",
        "It will depend on what your problem requires. However, most of the time, TensorFlow will automatically choose for you (when loading data or modelling data)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yezd0uF0-QG-"
      },
      "source": [
        "## Creating random tensors\n",
        "\n",
        "Random tensors are tensors of some abitrary size which contain random numbers.\n",
        "\n",
        "Why would you want to create random tensors?\n",
        "\n",
        "This is what neural networks use to intialize their weights (patterns) that they're trying to learn in the data.\n",
        "\n",
        "For example, the process of a neural network learning often involves taking a random n-dimensional array of numbers and refining them until they represent some kind of pattern (a compressed way to represent the original data)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H2X9xLrs-df_"
      },
      "source": [
        "We can create random tensors by using the tf.random.Generator class.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xf9x8lat9pmc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "88ff5d73-5390-4ff9-ff67-74bac5b1a784"
      },
      "source": [
        "# Create two random ( but the same) tensors\n",
        "random_1 = tf.random.Generator.from_seed(42) # Set the seed for reproducibility\n",
        "\n",
        "random_1 = random_1.normal(shape=(3 , 2)) # create a tensor a normal distribution\n",
        "\n",
        "random_2 = tf.random.Generator.from_seed(42)\n",
        "random_2 = random_2.normal(shape=(3 , 2))\n",
        "\n",
        "# Are they equal?\n",
        "random_1 , random_2 , random_1 == random_2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              " array([[-0.7565803 , -0.06854702],\n",
              "        [ 0.07595026, -1.2573844 ],\n",
              "        [-0.23193763, -1.8107855 ]], dtype=float32)>,\n",
              " <tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              " array([[-0.7565803 , -0.06854702],\n",
              "        [ 0.07595026, -1.2573844 ],\n",
              "        [-0.23193763, -1.8107855 ]], dtype=float32)>,\n",
              " <tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
              " array([[ True,  True],\n",
              "        [ True,  True],\n",
              "        [ True,  True]])>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YRNtUveA1TPu"
      },
      "source": [
        "\n",
        "The random tensors we've made are actually pseudorandom numbers (they appear as random, but really aren't).\n",
        "\n",
        "If we set a seed we'll get the same random numbers (if you've ever used NumPy, this is similar to np.random.seed(42)).\n",
        "\n",
        "Setting the seed says, \"hey, create some random numbers, but flavour them with X\" (X is the seed).\n",
        "\n",
        "What do you think will happen when we change the seed?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uCi4YMMb1V-o",
        "outputId": "e0dcafec-27d4-4c45-96e9-68510e481820"
      },
      "source": [
        "# Create two random (and different) tensors\n",
        "random_3 = tf.random.Generator.from_seed(42)\n",
        "random_3 = random_3.normal(shape=(3 , 2))\n",
        "\n",
        "random_4 = tf.random.Generator.from_seed(11)\n",
        "random_4 = random_4.normal(shape = (3 , 2))\n",
        "\n",
        "# check the tensors and see if they are equal\n",
        "random_3 , random_4 , random_1 == random_3 , random_3 == random_4"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              " array([[-0.7565803 , -0.06854702],\n",
              "        [ 0.07595026, -1.2573844 ],\n",
              "        [-0.23193763, -1.8107855 ]], dtype=float32)>,\n",
              " <tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              " array([[ 0.27305737, -0.29925638],\n",
              "        [-0.3652325 ,  0.61883307],\n",
              "        [-1.0130816 ,  0.28291714]], dtype=float32)>,\n",
              " <tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
              " array([[ True,  True],\n",
              "        [ True,  True],\n",
              "        [ True,  True]])>,\n",
              " <tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
              " array([[False, False],\n",
              "        [False, False],\n",
              "        [False, False]])>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GyuOpO3f2DCr"
      },
      "source": [
        "What if you wanted to shuffle the order of a tensor?\n",
        "\n",
        "Wait, why would you want to do that?\n",
        "\n",
        "Let's say you working with 15,000 images of cats and dogs and the first 10,000 images of were of cats and the next 5,000 were of dogs. This order could effect how a neural network learns (it may overfit by learning the order of the data), instead, it might be a good idea to move your data around."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xsi6Mgnn2DfV",
        "outputId": "56441034-10a9-4cba-a6c7-a522242b331c"
      },
      "source": [
        "# Shuffle a tensor (valuable for when you want to shuffle your data)\n",
        "\n",
        "not_shuffled = tf.constant([[10, 7],\n",
        "                            [3, 4],\n",
        "                            [2, 5]])\n",
        "\n",
        "# Get different results each time\n",
        "tf.random.shuffle(not_shuffled)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              "array([[ 2,  5],\n",
              "       [ 3,  4],\n",
              "       [10,  7]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7tllCwoi2_sU",
        "outputId": "1b6b3ae4-1eb7-416b-e316-4e5e9082fac8"
      },
      "source": [
        "# Shuffle in the same order every time using\n",
        "# the seed parameter (won't acutally be the same)\n",
        "\n",
        "tf.random.shuffle(not_shuffled , seed=42)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              "array([[ 2,  5],\n",
              "       [10,  7],\n",
              "       [ 3,  4]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CKdJ_MjJ4xKo"
      },
      "source": [
        "Wait... why didn't the numbers come out the same?\n",
        "\n",
        "It's due to rule #4 of the tf.random.set_seed() documentation.\n",
        "\n",
        "\"4. If both the global and the operation seed are set: Both seeds are used in conjunction to determine the random sequence.\"\n",
        "\n",
        "tf.random.set_seed(42) sets the global seed, and the seed parameter in tf.random.shuffle(seed=42) sets the operation seed.\n",
        "\n",
        "Because, \"Operations that rely on a random seed actually derive it from two seeds: the global and operation-level seeds. This sets the global seed.\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9-1qa-HA3bFi",
        "outputId": "2db0e73e-9436-4709-cbb5-08a281404d0f"
      },
      "source": [
        "# Shuffle the same oder every time\n",
        "\n",
        "# set the global random seed\n",
        "tf.random.set_seed(42)\n",
        "\n",
        "# Set the operation random seed\n",
        "tf.random.shuffle(not_shuffled , seed = 42)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              "array([[10,  7],\n",
              "       [ 3,  4],\n",
              "       [ 2,  5]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PgkrJtqH423Z",
        "outputId": "8e9b011a-2b4e-402c-d87c-36a39a704bd5"
      },
      "source": [
        "# Set the global random seed\n",
        "tf.random.set_seed(42) # if you comment this out you'll get different results\n",
        "\n",
        "# Set the operation random seed\n",
        "tf.random.shuffle(not_shuffled)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              "array([[ 3,  4],\n",
              "       [ 2,  5],\n",
              "       [10,  7]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dkv_J5c55f6L"
      },
      "source": [
        "## Other ways to make tensors\n",
        "Though you might rarely use these (remember, many tensor operations are done behind the scenes for you), you can use tf.ones() to create a tensor of all ones and tf.zeros() to create a tensor of all zeros."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hJcDqZWn5Q2v",
        "outputId": "9b32e1af-641f-4149-d4d1-1c6d5ede0dc7"
      },
      "source": [
        "# Make a tensor of all ones\n",
        "tf.ones(shape = (3 , 2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              "array([[1., 1.],\n",
              "       [1., 1.],\n",
              "       [1., 1.]], dtype=float32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xSkmP1x65ug6",
        "outputId": "7fb1e7e7-48e9-40e8-81af-fc74eb267ff9"
      },
      "source": [
        "# Make a tensor of all zeros\n",
        "tf.zeros(shape=(3 ,2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              "array([[0., 0.],\n",
              "       [0., 0.],\n",
              "       [0., 0.]], dtype=float32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3ecWq-Qd598Q"
      },
      "source": [
        "You can also turn NumPy arrays in into tensors.\n",
        "\n",
        "Remember, the main difference between tensors and NumPy arrays is that tensors can be run on GPUs.\n",
        "\n",
        "🔑 Note: A matrix or tensor is typically represented by a capital letter (e.g. X or A) where as a vector is typically represented by a lowercase letter (e.g. y or b)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fFuxnvK4505b",
        "outputId": "144d7fcd-a05c-4c11-8e15-b67e08c0902a"
      },
      "source": [
        "import numpy as np\n",
        "numpy_A = np.arange(1 , 25 , dtype=np.int32) # Create numpy array between 1 and 25\n",
        "\n",
        "A = tf.constant(numpy_A , shape=[2 , 4 , 3]) # note : the shape total (2*4*3) has to match the number of elemet in the array\n",
        "\n",
        "numpy_A , A"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
              "        18, 19, 20, 21, 22, 23, 24], dtype=int32),\n",
              " <tf.Tensor: shape=(2, 4, 3), dtype=int32, numpy=\n",
              " array([[[ 1,  2,  3],\n",
              "         [ 4,  5,  6],\n",
              "         [ 7,  8,  9],\n",
              "         [10, 11, 12]],\n",
              " \n",
              "        [[13, 14, 15],\n",
              "         [16, 17, 18],\n",
              "         [19, 20, 21],\n",
              "         [22, 23, 24]]], dtype=int32)>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6EcsdPdx63SL"
      },
      "source": [
        "## Getting information from tensors (shape, rank, size)\n",
        "There will be times when you'll want to get different pieces of information from your tensors, in particuluar, you should know the following tensor vocabulary:\n",
        "\n",
        " - Shape: The length (number of elements) of each of the dimensions of a tensor.\n",
        " - Rank: The number of tensor dimensions. A scalar has rank 0, a vector has rank 1, a matrix is rank 2, a tensor has rank n.\n",
        " - Axis or Dimension: A particular dimension of a tensor.\n",
        " - Size: The total number of items in the tensor.\n",
        " \n",
        "You'll use these especially when you're trying to line up the shapes of your data to the shapes of your model. For example, making sure the shape of your image tensors are the same shape as your models input layer.\n",
        "\n",
        "We've already seen one of these before using the ndim attribute. Let's see the rest."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TLZ0OEIC6jYu",
        "outputId": "63d5adfa-96df-4694-b4a3-c26939a07644"
      },
      "source": [
        "# Create a rank 4 tensor (4 dimension)\n",
        "rank_4_tensor = tf.zeros([2 , 3, 4, 5])\n",
        "rank_4_tensor"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3, 4, 5), dtype=float32, numpy=\n",
              "array([[[[0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.]],\n",
              "\n",
              "        [[0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.]],\n",
              "\n",
              "        [[0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.]]],\n",
              "\n",
              "\n",
              "       [[[0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.]],\n",
              "\n",
              "        [[0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.]],\n",
              "\n",
              "        [[0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.]]]], dtype=float32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "52dgEJtz7Z7h",
        "outputId": "48f3d509-7de9-412a-d828-536bbfa1ee62"
      },
      "source": [
        "rank_4_tensor.shape , rank_4_tensor.ndim , tf.size(rank_4_tensor)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorShape([2, 3, 4, 5]), 4, <tf.Tensor: shape=(), dtype=int32, numpy=120>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3y22SCZO7vGh",
        "outputId": "ecb53b07-4939-4431-fb30-57a3c5d1cbaf"
      },
      "source": [
        "# Get the various attributes of tensor\n",
        "print(\"Datatype of every element:\", rank_4_tensor.dtype)\n",
        "print(\"Number of dimensions (rank):\", rank_4_tensor.ndim)\n",
        "print(\"Shape of tensor:\", rank_4_tensor.shape)\n",
        "print(\"Elements along axis 0 of tensor:\", rank_4_tensor.shape[0])\n",
        "print(\"Elements along last axis of tensor:\", rank_4_tensor.shape[-1])\n",
        "print(\"Total number of elements (2*3*4*5):\", tf.size(rank_4_tensor).numpy()) # .numpy() converts to NumPy array"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Datatype of every element: <dtype: 'float32'>\n",
            "Number of dimensions (rank): 4\n",
            "Shape of tensor: (2, 3, 4, 5)\n",
            "Elements along axis 0 of tensor: 2\n",
            "Elements along last axis of tensor: 5\n",
            "Total number of elements (2*3*4*5): 120\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "InYnAi2u8RgE"
      },
      "source": [
        "\n",
        "You can also index tensors just like Python lists.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "03MBPLXp8MK9",
        "outputId": "87b6be8e-e018-409a-c94f-f4152b25963a"
      },
      "source": [
        "# Get the first 2 items of each dimension\n",
        "rank_4_tensor[:2, :2, :2, :2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2, 2, 2), dtype=float32, numpy=\n",
              "array([[[[0., 0.],\n",
              "         [0., 0.]],\n",
              "\n",
              "        [[0., 0.],\n",
              "         [0., 0.]]],\n",
              "\n",
              "\n",
              "       [[[0., 0.],\n",
              "         [0., 0.]],\n",
              "\n",
              "        [[0., 0.],\n",
              "         [0., 0.]]]], dtype=float32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AO1H0-Jg8iYX",
        "outputId": "2216e7ab-61db-470d-8023-4bea858d6b46"
      },
      "source": [
        "# Get the dimension from each index except for the final one\n",
        "rank_4_tensor[:1, :1, :1, :]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(1, 1, 1, 5), dtype=float32, numpy=array([[[[0., 0., 0., 0., 0.]]]], dtype=float32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ENPct4758lIy",
        "outputId": "5e2ae8f1-96cf-4f91-bf20-57200792c8bf"
      },
      "source": [
        "# create a rank 2 tensor ( 2 dimension)\n",
        "\n",
        "rank_2_tensor = tf.constant([[10, 7],\n",
        "                             [3, 4]])\n",
        "\n",
        "# Get the last item of each row\n",
        "rank_2_tensor[: , -1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([7, 4], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CIY3in4s9LYH"
      },
      "source": [
        "You can also add dimensions to your tensor whilst keeping the same information present using tf.newaxis."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nM79UHP29IHH",
        "outputId": "2df7fc34-a0f9-42a7-ed18-724af0d47874"
      },
      "source": [
        "# Add the extra dimension (to the end)\n",
        "\n",
        "rank_3_tensor = rank_2_tensor[..., tf.newaxis] # in Python \"...\" means - all dimension prior to\n",
        "\n",
        "rank_2_tensor , rank_3_tensor # Shape (2,2)  , shape(2,2,1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              " array([[10,  7],\n",
              "        [ 3,  4]], dtype=int32)>,\n",
              " <tf.Tensor: shape=(2, 2, 1), dtype=int32, numpy=\n",
              " array([[[10],\n",
              "         [ 7]],\n",
              " \n",
              "        [[ 3],\n",
              "         [ 4]]], dtype=int32)>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7enVLcjv9-r2"
      },
      "source": [
        "You can achieve the same using tf.expand_dims()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yBAXk9NM939h",
        "outputId": "45d3d4d4-b33c-48b4-b9f5-dd20d0fd46b1"
      },
      "source": [
        "tf.expand_dims(rank_2_tensor , axis=-1) # -1 means last axis\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2, 1), dtype=int32, numpy=\n",
              "array([[[10],\n",
              "        [ 7]],\n",
              "\n",
              "       [[ 3],\n",
              "        [ 4]]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oCStNgG--L15"
      },
      "source": [
        "## Manipulating tensors (tensor operations)\n",
        "Finding patterns in tensors (numberical representation of data) requires manipulating them.\n",
        "\n",
        "Again, when building models in TensorFlow, much of this pattern discovery is done for you.\n",
        "\n",
        "### Basic operations\n",
        "You can perform many of the basic mathematical operations directly on tensors using Pyhton operators such as, +, -, *."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JisgQOvF-JZN",
        "outputId": "79d47fd1-e770-43d4-9f64-4b37df6bb1b2"
      },
      "source": [
        "# You can add values to a tensor using the addition\n",
        "tensor = tf.constant([[10, 7],\n",
        "                      [3, 4]])\n",
        "tensor + 10"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[20, 17],\n",
              "       [13, 14]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aIeUW1v--w3m"
      },
      "source": [
        "Since we used tf.constant(), the original tensor is unchanged (the addition gets done on a copy)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-IHVqWPc-syC",
        "outputId": "dae78f6a-8e91-4d2a-d1a3-d46ecc221e69"
      },
      "source": [
        "tensor"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[10,  7],\n",
              "       [ 3,  4]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dPUvA_jc-14E"
      },
      "source": [
        "Other operators also work."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8RjK_6I_-yZf",
        "outputId": "62cc8f57-1842-4d16-e082-ad992cd8c6b8"
      },
      "source": [
        "# Multiplication (known as element-wise multiplication)\n",
        "tensor * 10"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[100,  70],\n",
              "       [ 30,  40]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QbwqPNOM-5NF",
        "outputId": "78671949-fef3-4e9b-d42d-81051b419162"
      },
      "source": [
        "# Subtraction\n",
        "tensor - 10"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[ 0, -3],\n",
              "       [-7, -6]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u8m1kjtT_AB3"
      },
      "source": [
        "You can also use the equivalent TensorFlow function. Using the TensorFlow function (where possible) has the advantage of being sped up later down the line when running as part of a TensorFlow graph."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kN16O6DJ-6ru",
        "outputId": "b3ae7a55-07d2-41fd-bf0a-61a60d68c3a2"
      },
      "source": [
        "# Use the tensorflow function equivalent of the '*' (multiply) operator\n",
        "tf.multiply(tensor , 10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[100,  70],\n",
              "       [ 30,  40]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Crf3LRQs_DR2",
        "outputId": "0665da17-c47e-4c29-f55b-ce8342ff1fdc"
      },
      "source": [
        "# The original tensor is still unchanged\n",
        "tensor"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[10,  7],\n",
              "       [ 3,  4]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qVStOwm5_jNp"
      },
      "source": [
        "## Matrix mutliplication\n",
        "One of the most common operations in machine learning algorithms is matrix multiplication.\n",
        "\n",
        "TensorFlow implements this matrix multiplication functionality in the tf.matmul() method.\n",
        "\n",
        "The main two rules for matrix multiplication to remember are:\n",
        "\n",
        "1.The inner dimensions must match:\n",
        " - (3, 5) @ (3, 5) won't work\n",
        " - (5, 3) @ (3, 5) will work\n",
        " - (3, 5) @ (5, 3) will work\n",
        "\n",
        "2.The resulting matrix has the shape of the outer dimensions:\n",
        " - (5, 3) @ (3, 5) -> (5, 5)\n",
        " - (3, 5) @ (5, 3) -> (3, 3)\n",
        " \n",
        "🔑 Note: '@' in Python is the symbol for matrix multiplication."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jbq3E-gN_JlA",
        "outputId": "b8600c03-62f7-41b9-dfcd-e3cccee6f3e5"
      },
      "source": [
        "# Matrix multiplication in Tensorflow\n",
        "print(tensor)\n",
        "tf.matmul(tensor , tensor)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tf.Tensor(\n",
            "[[10  7]\n",
            " [ 3  4]], shape=(2, 2), dtype=int32)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[121,  98],\n",
              "       [ 42,  37]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-T8NjPgk_8LG",
        "outputId": "ae3a2a77-f0f4-4201-cc38-06a28711e807"
      },
      "source": [
        "# Matrix multiplication with Python operator '@'\n",
        "tensor @ tensor"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[121,  98],\n",
              "       [ 42,  37]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1ZQzuwsyAD0i"
      },
      "source": [
        "Both of these examples work because our tensor variable is of shape (2, 2).\n",
        "\n",
        "What if we created some tensors which had mismatched shapes?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_5NrgdyX__2r",
        "outputId": "323e433a-60c2-49ac-bcff-68b455928c97"
      },
      "source": [
        "# Create (3, 2) tensor\n",
        "X = tf.constant([[1, 2],\n",
        "                 [3, 4],\n",
        "                 [5, 6]])\n",
        "\n",
        "# Create another (3, 2) tensor\n",
        "Y = tf.constant([[7, 8],\n",
        "                 [9, 10],\n",
        "                 [11, 12]])\n",
        "X , Y"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              " array([[1, 2],\n",
              "        [3, 4],\n",
              "        [5, 6]], dtype=int32)>, <tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              " array([[ 7,  8],\n",
              "        [ 9, 10],\n",
              "        [11, 12]], dtype=int32)>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 253
        },
        "id": "pZKwHm-9AGKV",
        "outputId": "a6b090ed-4ef9-4475-df2e-f11c4e804b99"
      },
      "source": [
        "# Try to matrix multiply them (will error)\n",
        "X @ Y"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "InvalidArgumentError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mInvalidArgumentError\u001b[0m                      Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-73-62e1e4702ffd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Try to matrix multiply them (will error)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mX\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/ops/math_ops.py\u001b[0m in \u001b[0;36mbinary_op_wrapper\u001b[0;34m(x, y)\u001b[0m\n\u001b[1;32m   1162\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mop_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1163\u001b[0m       \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1164\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1165\u001b[0m       \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mTypeError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1166\u001b[0m         \u001b[0;31m# Even if dispatching the op failed, the RHS may be a tensor aware\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/util/dispatch.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    199\u001b[0m     \u001b[0;34m\"\"\"Call target, and fall back on dispatchers if there is a TypeError.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    200\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 201\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    202\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mTypeError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    203\u001b[0m       \u001b[0;31m# Note: convert_to_eager_tensor currently raises a ValueError, not a\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/ops/math_ops.py\u001b[0m in \u001b[0;36mmatmul\u001b[0;34m(a, b, transpose_a, transpose_b, adjoint_a, adjoint_b, a_is_sparse, b_is_sparse, name)\u001b[0m\n\u001b[1;32m   3313\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3314\u001b[0m       return gen_math_ops.mat_mul(\n\u001b[0;32m-> 3315\u001b[0;31m           a, b, transpose_a=transpose_a, transpose_b=transpose_b, name=name)\n\u001b[0m\u001b[1;32m   3316\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3317\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/ops/gen_math_ops.py\u001b[0m in \u001b[0;36mmat_mul\u001b[0;34m(a, b, transpose_a, transpose_b, name)\u001b[0m\n\u001b[1;32m   5530\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0m_result\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5531\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0m_core\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 5532\u001b[0;31m       \u001b[0m_ops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraise_from_not_ok_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   5533\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0m_core\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_FallbackException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   5534\u001b[0m       \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36mraise_from_not_ok_status\u001b[0;34m(e, name)\u001b[0m\n\u001b[1;32m   6860\u001b[0m   \u001b[0mmessage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmessage\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\" name: \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m\"\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   6861\u001b[0m   \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 6862\u001b[0;31m   \u001b[0msix\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraise_from\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_status_to_exception\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmessage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   6863\u001b[0m   \u001b[0;31m# pylint: enable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   6864\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/six.py\u001b[0m in \u001b[0;36mraise_from\u001b[0;34m(value, from_value)\u001b[0m\n",
            "\u001b[0;31mInvalidArgumentError\u001b[0m: Matrix size-incompatible: In[0]: [3,2], In[1]: [3,2] [Op:MatMul]"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2TBLFxZTA0Ae"
      },
      "source": [
        "Trying to matrix multiply two tensors with the shape (3, 2) errors because the inner dimensions don't match.\n",
        "\n",
        "We need to either:\n",
        "\n",
        " - Reshape X to (2, 3) so it's (2, 3) @ (3, 2).\n",
        " - Reshape Y to (3, 2) so it's (3, 2) @ (2, 3).\n",
        "\n",
        "We can do this with either:\n",
        "\n",
        " - tf.reshape() - allows us to reshape a tensor into a defined shape.\n",
        " - tf.transpose() - switches the dimensions of a given tensor.\n",
        "\n",
        "Let's try tf.reshape() first."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m445epf5AWRR",
        "outputId": "e060edae-fdce-44ce-8fb3-9d3a8000be4d"
      },
      "source": [
        "# Example of reshape (3, 2) -> (2, 3)\n",
        "tf.reshape(Y , shape =(2 ,3))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3), dtype=int32, numpy=\n",
              "array([[ 7,  8,  9],\n",
              "       [10, 11, 12]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zotIr_5SBCh4",
        "outputId": "9ecc4df7-6a6b-40db-f5fa-5034ed15b61c"
      },
      "source": [
        "# Try matrix multiplication with reshaped Y\n",
        "X @ tf.reshape(Y, shape=(2, 3))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              "array([[ 27,  30,  33],\n",
              "       [ 61,  68,  75],\n",
              "       [ 95, 106, 117]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wSd2v4ROBMjk"
      },
      "source": [
        "It worked, let's try the same with a reshaped X, except this time we'll use tf.transpose() and tf.matmul()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "naUgX3IPBFBW",
        "outputId": "a7729cad-e6dc-4990-8bff-99f03996af6a"
      },
      "source": [
        "# Example of transpose (3, 2) -> (2, 3)\n",
        "tf.transpose(X)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3), dtype=int32, numpy=\n",
              "array([[1, 3, 5],\n",
              "       [2, 4, 6]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kaLxIyPhBOke",
        "outputId": "b55ef3cb-c08b-493e-9337-b6938de4f210"
      },
      "source": [
        "# Try matrix multiplication \n",
        "tf.matmul(tf.transpose(X), Y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[ 89,  98],\n",
              "       [116, 128]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PXVKMWazBQx6",
        "outputId": "8ed64831-b114-4245-e3d5-ce383ee64d8e"
      },
      "source": [
        "# You can achieve the same result with parameters\n",
        "tf.matmul(a=X, b=Y, transpose_a=True, transpose_b=False)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[ 89,  98],\n",
              "       [116, 128]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 78
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "simZnIFUBgY0"
      },
      "source": [
        "Notice the difference in the resulting shapes when tranposing X or reshaping Y.\n",
        "\n",
        "This is because of the 2nd rule mentioned above:\n",
        "\n",
        " - (3, 2) @ (2, 3) -> (2, 2) done with tf.matmul(tf.transpose(X), Y)\n",
        " - (2, 3) @ (3, 2) -> (3, 3) done with X @ tf.reshape(Y, shape=(2, 3))\n",
        "\n",
        "This kind of data manipulation is a reminder: you'll spend a lot of your time in machine learning and working with neural networks reshaping data (in the form of tensors) to prepare it to be used with various operations (such as feeding it to a model).\n",
        "\n",
        "### The dot product\n",
        "Multiplying matrices by eachother is also referred to as the dot product.\n",
        "\n",
        "You can perform the tf.matmul() operation using tf.tensordot()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XrP-iBHtBUzt",
        "outputId": "21ef6281-204d-4c0a-95ec-8d394afa8131"
      },
      "source": [
        "# Perform the dot product on X and Y (requires X to be transposed)\n",
        "tf.tensordot(tf.transpose(X) , Y , axes=1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[ 89,  98],\n",
              "       [116, 128]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n_OxIm_rCBuS"
      },
      "source": [
        "You might notice that although using both reshape and tranpose work, you get different results when using each.\n",
        "\n",
        "Let's see an example, first with tf.transpose() then with tf.reshape()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eco7rqrkBzv3",
        "outputId": "90ed1c37-a195-44ee-d909-59128d7a9463"
      },
      "source": [
        "# Perform matrix multiplication between X and Y (transposed)\n",
        "tf.matmul(X, tf.transpose(Y))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              "array([[ 23,  29,  35],\n",
              "       [ 53,  67,  81],\n",
              "       [ 83, 105, 127]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yTe73FKNCEiy",
        "outputId": "9b2aa1a5-842e-4495-b6bd-d8bd2043e827"
      },
      "source": [
        "# Perform matrix multiplication between X and Y (reshaped)\n",
        "tf.matmul(X, tf.reshape(Y, (2, 3)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              "array([[ 27,  30,  33],\n",
              "       [ 61,  68,  75],\n",
              "       [ 95, 106, 117]], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 81
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DNdsAJ0DCXya"
      },
      "source": [
        "\n",
        "Hmm... they result in different values.\n",
        "\n",
        "Which is strange because when dealing with Y (a (3x2) matrix), reshaping to (2, 3) and tranposing it result in the same shape."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "stM8uu5NCIXf",
        "outputId": "c5e52066-30a7-4360-f323-c676e28f023b"
      },
      "source": [
        "# Check shapes of Y, reshaped Y and tranposed Y\n",
        "Y.shape, tf.reshape(Y, (2, 3)).shape, tf.transpose(Y).shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorShape([3, 2]), TensorShape([2, 3]), TensorShape([2, 3]))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cFM8ZGPICcpg"
      },
      "source": [
        "But calling tf.reshape() and tf.transpose() on Y don't necessarily result in the same values."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w-HT0DOgC0GL"
      },
      "source": [
        "As you can see, the outputs of tf.reshape() and tf.transpose() when called on Y, even though they have the same shape, are different.\n",
        "\n",
        "This can be explained by the default behaviour of each method:\n",
        "\n",
        " - tf.reshape() - change the shape of the given tensor (first) and then insert values in order they appear (in our case, 7, 8, 9, 10, 11, 12).\n",
        " - tf.transpose() - swap the order of the axes, by default the last axis becomes the first, however the order can be changed using the perm parameter."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q60MBkc7C8pD"
      },
      "source": [
        "So which should you use?\n",
        "\n",
        "Again, most of the time these operations (when they need to be run, such as during the training a neural network, will be implemented for you).\n",
        "\n",
        "But generally, whenever performing a matrix multiplication and the shapes of two matrices don't line up, you will transpose (not reshape) one of them in order to line them up."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "08TxRT1ZGsfM"
      },
      "source": [
        "## Matrix multiplication tidbits\n",
        " - If we transposed Y, it would be represented as $\\mathbf{Y}^\\mathsf{T}$ (note the capital T for tranpose).\n",
        " - Get an illustrative view of matrix multiplication by Math is Fun."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Icu-H3evG6md"
      },
      "source": [
        "## Changing the datatype of a tensor\n",
        "Sometimes you'll want to alter the default datatype of your tensor.\n",
        "\n",
        "This is common when you want to compute using less precision (e.g. 16-bit floating point numbers vs. 32-bit floating point numbers).\n",
        "\n",
        "Computing with less precision is useful on devices with less computing capacity such as mobile devices (because the less bits, the less space the computations require).\n",
        "\n",
        "You can change the datatype of a tensor using tf.cast()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uEI6vfyCCaSo",
        "outputId": "2dc50948-d923-4691-f148-800b54f67d8e"
      },
      "source": [
        "# Create a new tensor with default datatype (float32)\n",
        "B = tf.constant([1.7 , 7.4])\n",
        "\n",
        "# Create a new tensor with default datatype (int32)\n",
        "C = tf.constant([1,7])\n",
        "\n",
        "B , C"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(2,), dtype=float32, numpy=array([1.7, 7.4], dtype=float32)>,\n",
              " <tf.Tensor: shape=(2,), dtype=int32, numpy=array([1, 7], dtype=int32)>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ht40lzrgHTwJ",
        "outputId": "fa380690-a134-42ea-e02a-73e4d8cc08a4"
      },
      "source": [
        "\n",
        "# Change from float32 to float16 (reduced precision)\n",
        "B = tf.cast(B , dtype=tf.float16)\n",
        "B"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=float16, numpy=array([1.7, 7.4], dtype=float16)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "inaCVCFnHcLo",
        "outputId": "fd27dda5-8f95-47a1-ead9-72752409d96b"
      },
      "source": [
        "# Change from int32 to float32\n",
        "C = tf.cast(C, dtype=tf.float32)\n",
        "C"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=float32, numpy=array([1., 7.], dtype=float32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1b__QHY5HjRf"
      },
      "source": [
        "## Getting the absolute value\n",
        "Sometimes you'll want the absolute values (all values are positive) of elements in your tensors.\n",
        "\n",
        "To do so, you can use tf.abs()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W2_YOzThHf0L",
        "outputId": "0a6f6844-024d-4033-c027-ea8712b8fae5"
      },
      "source": [
        "# Create tensor with negative values\n",
        "D = tf.constant([-7, -10])\n",
        "D"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([ -7, -10], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DzF3fuTKHp6z",
        "outputId": "d088cc9f-8134-43b5-adc0-b8ce4ce7c5d1"
      },
      "source": [
        "# Get the absolute values\n",
        "tf.abs(D)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([ 7, 10], dtype=int32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PLJUTWn-LKXN"
      },
      "source": [
        "## Finding the min, max, mean, sum (aggregation)\n",
        "You can quickly aggregate (perform a calculation on a whole tensor) tensors to find things like the minimum value, maximum value, mean and sum of all the elements.\n",
        "\n",
        "To do so, aggregation methods typically have the syntax reduce()_[action], such as:\n",
        "\n",
        " - tf.reduce_min() - find the minimum value in a tensor.\n",
        " - tf.reduce_max() - find the maximum value in a tensor (helpful for when you want to find the highest prediction probability).\n",
        " - tf.reduce_mean() - find the mean of all elements in a tensor.\n",
        " - tf.reduce_sum() - find the sum of all elements in a tensor.\n",
        " - Note: typically, each of these is under the math module, e.g. tf.math.reduce_min() but you can use the alias tf.reduce_min().\n",
        " \n",
        "Let's see them in action."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z9Xb0clYHscE",
        "outputId": "235d12b8-1d04-43e4-9a46-77a981be30e6"
      },
      "source": [
        "# Create a tensor with 50 random values between 0 and 100\n",
        "E = tf.constant(np.random.randint(low=0, high=100, size=50))\n",
        "E"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(50,), dtype=int64, numpy=\n",
              "array([ 3, 74, 66, 96, 29, 85, 48,  0,  1, 58, 87, 66, 97,  9,  6, 44, 99,\n",
              "       48, 93, 10, 56, 73, 79, 39, 77, 62, 15, 50, 45, 56, 82, 91, 17, 90,\n",
              "       88, 83, 62, 50, 55, 29,  7, 67, 66,  3, 65, 92,  0, 41, 19, 56])>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ctGp8G7ULa4_",
        "outputId": "abc0be33-aafb-4a8c-f578-d7d6d11f8b98"
      },
      "source": [
        "# Find the minimum\n",
        "tf.reduce_min(E)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pheHpaMELfjH",
        "outputId": "959f92c3-a82b-4d37-8e35-9f8ce83af7b6"
      },
      "source": [
        "# find the maximum\n",
        "tf.reduce_max(E)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=99>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YxQmPjUJLjaL",
        "outputId": "047cd5a9-9f37-4a45-abc8-67c4a5cd4ddf"
      },
      "source": [
        "# find the mean\n",
        "tf.reduce_mean(E)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=52>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 92
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-iecNbMZLofF",
        "outputId": "140edb23-178b-4760-c806-394cd03349e0"
      },
      "source": [
        "# Find the sum\n",
        "tf.reduce_sum(E)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=2634>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 93
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ooIoHoMM9kj"
      },
      "source": [
        "\n",
        "You can also find the standard deviation (tf.reduce_std()) and variance (tf.reduce_variance()) of elements in a tensor using similar methods."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4JTuqIy2NM5P"
      },
      "source": [
        "## Finding the positional maximum and minimum\n",
        "How about finding the position a tensor where the maximum value occurs?\n",
        "\n",
        "This is helpful when you want to line up your labels (say ['Green', 'Blue', 'Red']) with your prediction probabilities tensor (e.g. [0.98, 0.01, 0.01]).\n",
        "\n",
        "In this case, the predicted label (the one with the highest prediction probability) would be 'Green'.\n",
        "\n",
        "You can do the same for the minimum (if required) with the following:\n",
        "\n",
        " - tf.argmax() - find the position of the maximum element in a given tensor.\n",
        " - tf.argmin() - find the position of the minimum element in a given tensor."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HOoDwlfVL3q5",
        "outputId": "8abd2793-1a29-4e67-d730-722d5ae82537"
      },
      "source": [
        "# Create a tensor with 50 values between 0 and 1\n",
        "F = tf.constant(np.random.random(50))\n",
        "F"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(50,), dtype=float64, numpy=\n",
              "array([0.40910395, 0.91730506, 0.28291924, 0.5402286 , 0.6518522 ,\n",
              "       0.45452785, 0.65148803, 0.43379752, 0.04921446, 0.54730037,\n",
              "       0.3118768 , 0.89814646, 0.12704145, 0.61491669, 0.61085687,\n",
              "       0.82249443, 0.84845903, 0.98395808, 0.4649418 , 0.02603005,\n",
              "       0.12539563, 0.46597381, 0.7065907 , 0.21061729, 0.11728186,\n",
              "       0.98767468, 0.16949777, 0.51517114, 0.14093883, 0.14424541,\n",
              "       0.95742018, 0.85673403, 0.34279344, 0.29336158, 0.79242771,\n",
              "       0.10139525, 0.8914332 , 0.87921482, 0.43949371, 0.61992722,\n",
              "       0.8246161 , 0.43839595, 0.72102272, 0.09686045, 0.34018859,\n",
              "       0.26904489, 0.11739399, 0.65179159, 0.66358024, 0.26253643])>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 96
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v4dBgJLvNv0W",
        "outputId": "b5d41a2e-8ad4-41f9-8ef8-7910df43aefe"
      },
      "source": [
        "# find the maximum element position of F\n",
        "tf.argmax(F)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=25>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 97
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-EDa7dvlOGiT",
        "outputId": "0e118520-9fa8-4466-c62c-92d2c97924a2"
      },
      "source": [
        "# Find the minimum element position of F\n",
        "tf.argmin(F)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=19>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 98
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "034ZCK4tOKG3",
        "outputId": "0300a002-ce81-4306-e99c-b1db8b3b436e"
      },
      "source": [
        "# Find the maximum element position of F\n",
        "print(f\"The maximum value of F is at position: {tf.argmax(F).numpy()}\") \n",
        "print(f\"The maximum value of F is: {tf.reduce_max(F).numpy()}\") \n",
        "print(f\"Using tf.argmax() to index F, the maximum value of F is: {F[tf.argmax(F)].numpy()}\")\n",
        "print(f\"Are the two max values the same (they should be)? {F[tf.argmax(F)].numpy() == tf.reduce_max(F).numpy()}\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The maximum value of F is at position: 25\n",
            "The maximum value of F is: 0.9876746766961774\n",
            "Using tf.argmax() to index F, the maximum value of F is: 0.9876746766961774\n",
            "Are the two max values the same (they should be)? True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OKt4FrK8OyKh"
      },
      "source": [
        "\n",
        "## Squeezing a tensor (removing all single dimensions)\n",
        "If you need to remove single-dimensions from a tensor (dimensions with size 1), you can use tf.squeeze().\n",
        "\n",
        "tf.squeeze() - remove all dimensions of 1 from a tensor."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0s7ScfWlOY0U",
        "outputId": "28b62316-d945-4c0a-b2fd-4b0b6e573cd8"
      },
      "source": [
        "# Create a rank 5 (5 dimensions) tensor of 50 numbers between 0 and 100\n",
        "G = tf.constant(np.random.randint(0 , 100 , 50) , shape=(1 , 1, 1 ,1 ,50))\n",
        "G.shape , G.ndim"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorShape([1, 1, 1, 1, 50]), 5)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xvxtts-jPO06",
        "outputId": "e6311786-02e0-4d5c-90c9-11ce21e08944"
      },
      "source": [
        "# Squeeze tensor G (remove all 1 dimensions)\n",
        "G_squeezed = tf.squeeze(G)\n",
        "G_squeezed.shape , G_squeezed.ndim"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorShape([50]), 1)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dwocfHhuPrkQ"
      },
      "source": [
        "## One-hot encoding\n",
        "If you have a tensor of indicies and would like to one-hot encode it, you can use tf.one_hot().\n",
        "\n",
        "You should also specify the depth parameter (the level which you want to one-hot encode to)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dpk_1iS2Phkx",
        "outputId": "c95cd8ac-b61a-4532-dcc4-11798b73602c"
      },
      "source": [
        "# Create a list of indices\n",
        "some_list = [0 , 1 , 2, 3]\n",
        "\n",
        "# one hot encode them\n",
        "tf.one_hot(some_list , depth=4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(4, 4), dtype=float32, numpy=\n",
              "array([[1., 0., 0., 0.],\n",
              "       [0., 1., 0., 0.],\n",
              "       [0., 0., 1., 0.],\n",
              "       [0., 0., 0., 1.]], dtype=float32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8s-IR02FP9yh"
      },
      "source": [
        "You can also specify values for on_value and off_value instead of the default 0 and 1."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Lv2V6fI3P5vt",
        "outputId": "cdd8c6cc-1fe7-4c7e-d761-32afaa592d94"
      },
      "source": [
        "# Specify custom values for on and off encoding\n",
        "tf.one_hot(some_list, depth=4, on_value=\"We're live!\", off_value=\"Offline\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(4, 4), dtype=string, numpy=\n",
              "array([[b\"We're live!\", b'Offline', b'Offline', b'Offline'],\n",
              "       [b'Offline', b\"We're live!\", b'Offline', b'Offline'],\n",
              "       [b'Offline', b'Offline', b\"We're live!\", b'Offline'],\n",
              "       [b'Offline', b'Offline', b'Offline', b\"We're live!\"]], dtype=object)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 103
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DqANGkSBQSly"
      },
      "source": [
        "## Squaring, log, square root\n",
        "Many other common mathematical operations you'd like to perform at some stage, probably exist.\n",
        "\n",
        "Let's take a look at:\n",
        "\n",
        " - tf.square() - get the square of every value in a tensor.\n",
        " - tf.sqrt() - get the squareroot of every value in a tensor (note: the elements need to be floats or this will error).\n",
        " - tf.math.log() - get the natural log of every value in a tensor (elements need to floats)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "--aP68dBQI3c",
        "outputId": "10ad4dff-e20b-4f84-a18d-95067167362d"
      },
      "source": [
        "# Create a new tensor\n",
        "H = tf.constant(np.arange(1 , 10))\n",
        "H"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(9,), dtype=int64, numpy=array([1, 2, 3, 4, 5, 6, 7, 8, 9])>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 104
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b6J3Ash5QezZ",
        "outputId": "f32e5480-58f8-4dba-e8ed-07a0a60913c9"
      },
      "source": [
        "# Square it\n",
        "tf.square(H)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(9,), dtype=int64, numpy=array([ 1,  4,  9, 16, 25, 36, 49, 64, 81])>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 105
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 303
        },
        "id": "Xm3mYx2-QiUd",
        "outputId": "1773eaa6-bd1d-4a83-8cf3-6eea68f2c20e"
      },
      "source": [
        "# Find the squareroot (will error ) , needs to be non-integer\n",
        "tf.sqrt(H)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "InvalidArgumentError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mInvalidArgumentError\u001b[0m                      Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-106-f9fa0c0f32a0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Find the squareroot (will error ) , needs to be non-integer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mH\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/util/dispatch.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    199\u001b[0m     \u001b[0;34m\"\"\"Call target, and fall back on dispatchers if there is a TypeError.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    200\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 201\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    202\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mTypeError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    203\u001b[0m       \u001b[0;31m# Note: convert_to_eager_tensor currently raises a ValueError, not a\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/ops/math_ops.py\u001b[0m in \u001b[0;36msqrt\u001b[0;34m(x, name)\u001b[0m\n\u001b[1;32m   4901\u001b[0m     \u001b[0mA\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;31m`\u001b[0m \u001b[0mof\u001b[0m \u001b[0msame\u001b[0m \u001b[0msize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtype\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0msparsity\u001b[0m \u001b[0;32mas\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0mx\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   4902\u001b[0m   \"\"\"\n\u001b[0;32m-> 4903\u001b[0;31m   \u001b[0;32mreturn\u001b[0m \u001b[0mgen_math_ops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   4904\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   4905\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/ops/gen_math_ops.py\u001b[0m in \u001b[0;36msqrt\u001b[0;34m(x, name)\u001b[0m\n\u001b[1;32m  10035\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0m_result\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m  10036\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0m_core\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m> 10037\u001b[0;31m       \u001b[0m_ops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraise_from_not_ok_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m  10038\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0m_core\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_FallbackException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m  10039\u001b[0m       \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36mraise_from_not_ok_status\u001b[0;34m(e, name)\u001b[0m\n\u001b[1;32m   6860\u001b[0m   \u001b[0mmessage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmessage\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\" name: \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m\"\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   6861\u001b[0m   \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 6862\u001b[0;31m   \u001b[0msix\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraise_from\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_status_to_exception\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmessage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   6863\u001b[0m   \u001b[0;31m# pylint: enable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   6864\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/six.py\u001b[0m in \u001b[0;36mraise_from\u001b[0;34m(value, from_value)\u001b[0m\n",
            "\u001b[0;31mInvalidArgumentError\u001b[0m: Value for attr 'T' of int64 is not in the list of allowed values: bfloat16, half, float, double, complex64, complex128\n\t; NodeDef: {{node Sqrt}}; Op<name=Sqrt; signature=x:T -> y:T; attr=T:type,allowed=[DT_BFLOAT16, DT_HALF, DT_FLOAT, DT_DOUBLE, DT_COMPLEX64, DT_COMPLEX128]> [Op:Sqrt]"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PLVDF2HqQsqL",
        "outputId": "c0016003-1869-4393-9df3-89aea1b5d0f2"
      },
      "source": [
        "# Change the H into float32\n",
        "H = tf.cast(H , dtype=tf.float32)\n",
        "H"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(9,), dtype=float32, numpy=array([1., 2., 3., 4., 5., 6., 7., 8., 9.], dtype=float32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 107
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wG7N3C6yQ0tP",
        "outputId": "c4b07ae8-0730-4fd8-c3c5-c659e3724c0d"
      },
      "source": [
        "# Find the sqaure root\n",
        "tf.sqrt(H)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(9,), dtype=float32, numpy=\n",
              "array([0.99999994, 1.4142134 , 1.7320508 , 1.9999999 , 2.236068  ,\n",
              "       2.4494896 , 2.6457512 , 2.8284268 , 3.        ], dtype=float32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 108
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-tWzK4RKQ4Az",
        "outputId": "09f14813-1fbe-43ec-ad7f-fc11c0948700"
      },
      "source": [
        "# Find the log (input also needs to be float)\n",
        "tf.math.log(H)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(9,), dtype=float32, numpy=\n",
              "array([0.       , 0.6931472, 1.0986123, 1.3862944, 1.609438 , 1.7917595,\n",
              "       1.9459102, 2.0794415, 2.1972246], dtype=float32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ddyuREPXRCxM"
      },
      "source": [
        "## Manipulating tf.Variable tensors\n",
        "Tensors created with tf.Variable() can be changed in place using methods such as:\n",
        "\n",
        " - .assign() - assign a different value to a particular index of a variable tensor.\n",
        " - .add_assign() - add to an existing value and reassign it at a particular index of a variable tensor."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tsy4mOQ3Q-Ap",
        "outputId": "5644578a-9033-4f75-a24e-02f68831ee53"
      },
      "source": [
        "# Create a variable tensor\n",
        "I = tf.Variable(np.arange(0, 5))\n",
        "I"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Variable 'Variable:0' shape=(5,) dtype=int64, numpy=array([0, 1, 2, 3, 4])>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 110
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y38EQKD2RIs6",
        "outputId": "11196a3f-2c0a-4ee6-c3b4-d1f911000971"
      },
      "source": [
        "# Assign the final value a new value of 50\n",
        "I.assign([0 , 1 , 2,  3 , 50])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Variable 'UnreadVariable' shape=(5,) dtype=int64, numpy=array([ 0,  1,  2,  3, 50])>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 112
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rEA-kzwqRPXQ",
        "outputId": "b8cc5ce0-ac28-47d0-bf73-38529c98bba2"
      },
      "source": [
        "I"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Variable 'Variable:0' shape=(5,) dtype=int64, numpy=array([ 0,  1,  2,  3, 50])>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 113
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1pX_WkbURUbj",
        "outputId": "ddd7bf55-2eee-43a5-b083-d30ccd8ca6f5"
      },
      "source": [
        "# Add 10 to every element in I\n",
        "I.assign_add([10, 10, 10, 10, 10])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Variable 'UnreadVariable' shape=(5,) dtype=int64, numpy=array([10, 11, 12, 13, 60])>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bL41r0_4RXnb",
        "outputId": "c08159e1-e4e1-4526-c774-7e2455972c6a"
      },
      "source": [
        "I"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Variable 'Variable:0' shape=(5,) dtype=int64, numpy=array([10, 11, 12, 13, 60])>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 115
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U8Jc9_C4RpxZ"
      },
      "source": [
        "\n",
        "## Tensors and NumPy\n",
        "We've seen some examples of tensors interact with NumPy arrays, such as, using NumPy arrays to create tensors.\n",
        "\n",
        "Tensors can also be converted to NumPy arrays using:\n",
        "\n",
        " - np.array() - pass a tensor to convert to an ndarray (NumPy's main datatype).\n",
        " - tensor.numpy() - call on a tensor to convert to an ndarray.\n",
        " \n",
        "Doing this is helpful as it makes tensors iterable as well as allows us to use any of NumPy's methods on them."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HsyhwCbHRcCu",
        "outputId": "46f4e5df-dd65-4a34-cf41-594532e1805c"
      },
      "source": [
        "# Create a tensor from a NumPy array\n",
        "J = tf.constant(np.array([3., 7., 10.]))\n",
        "J"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=float64, numpy=array([ 3.,  7., 10.])>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 116
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kPEToL-QRuKk",
        "outputId": "7650d0a0-8263-4818-d834-d0fb69ed562f"
      },
      "source": [
        "# Convert tensor J to NumPy with np.array()\n",
        "np.array(J) , type(np.array(J))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([ 3.,  7., 10.]), numpy.ndarray)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 117
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YXTlcvkTR1Qr",
        "outputId": "2567fb70-7a42-49ee-9cd9-091969281ddf"
      },
      "source": [
        "# Convert tensor J to NumPy with .numpy()\n",
        "J.numpy() , type(J.numpy())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([ 3.,  7., 10.]), numpy.ndarray)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 118
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fAEXXWRhSE4C"
      },
      "source": [
        "\n",
        "By default tensors have dtype=float32, where as NumPy arrays have dtype=float64.\n",
        "\n",
        "This is because neural networks (which are usually built with TensorFlow) can generally work very well with less precision (32-bit rather than 64-bit)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FtYUQEvIR8ZD",
        "outputId": "cffba811-19dd-4d5b-a780-6d636d16d7fc"
      },
      "source": [
        "# Create a tensor from NumPy and from an array\n",
        "numpy_J = tf.constant(np.array([3., 7., 10.])) # will be float64 (due to NumPy)\n",
        "tensor_J = tf.constant([3., 7., 10.]) # will be float32 (due to being TensorFlow default)\n",
        "numpy_J.dtype, tensor_J.dtype"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tf.float64, tf.float32)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 119
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iLBq1K_PSpXz"
      },
      "source": [
        "## Using @tf.function\n",
        "In your TensorFlow adventures, you might come across Python functions which have the decorator @tf.function.\n",
        "\n",
        "If you aren't sure what Python decorators do, read RealPython's guide on them.\n",
        "\n",
        "But in short, decorators modify a function in one way or another.\n",
        "\n",
        "In the @tf.function decorator case, it turns a Python function into a callable TensorFlow graph. Which is a fancy way of saying, if you've written your own Python function, and you decorate it with @tf.function, when you export your code (to potentially run on another device), TensorFlow will attempt to convert it into a fast(er) version of itself (by making it part of a computation graph).\n",
        "\n",
        "For more on this, read the Better performnace with tf.function guide."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dbUCiMLPSWNN",
        "outputId": "4ee74479-8cee-4937-e265-03c24cbec455"
      },
      "source": [
        "# Create a simple function\n",
        "def function(x , y):\n",
        "  return x ** 2 + y\n",
        "\n",
        "x = tf.constant(np.arange(0 ,10))\n",
        "y = tf.constant(np.arange(10 , 20))\n",
        "function(x , y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(10,), dtype=int64, numpy=array([ 10,  12,  16,  22,  30,  40,  52,  66,  82, 100])>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 120
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "47zmKtCaS6N1",
        "outputId": "e66dc963-471d-4a8a-830f-d6dabc4a1ffe"
      },
      "source": [
        "# Create the same function and decorate it with tf.function\n",
        "@tf.function\n",
        "def tf_function(x, y):\n",
        "  return x ** 2 + y\n",
        "\n",
        "tf_function(x, y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(10,), dtype=int64, numpy=array([ 10,  12,  16,  22,  30,  40,  52,  66,  82, 100])>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 121
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dm69tp-uTFi1"
      },
      "source": [
        "If you noticed no difference between the above two functions (the decorated one and the non-decorated one) you'd be right.\n",
        "\n",
        "Much of the difference happens behind the scenes. One of the main ones being potential code speed-ups where possible."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QxYfGchhTOcd"
      },
      "source": [
        "## Finding access to GPUs\n",
        "We've mentioned GPUs plenty of times throughout this notebook.\n",
        "\n",
        "So how do you check if you've got one available?\n",
        "\n",
        "You can check if you've got access to a GPU using tf.config.list_physical_devices()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tPFFdjcCS_H8",
        "outputId": "917e6fc7-ee66-418a-cc07-2f2cdb4c499a"
      },
      "source": [
        "print(tf.config.list_physical_devices(\"GPU\"))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PVAgR3Q-Tcym"
      },
      "source": [
        "If the above outputs an empty array (or nothing), it means you don't have access to a GPU (or at least TensorFlow can't find it).\n",
        "\n",
        "If you're running in Google Colab, you can access a GPU by going to Runtime -> Change Runtime Type -> Select GPU (note: after doing this your notebook will restart and any variables you've saved will be lost).\n",
        "\n",
        "Once you've changed your runtime type, run the cell below."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qk_9LHXMTiVa"
      },
      "source": [
        "You can also find information about your GPU using !nvidia-smi."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SHiPlmK5TUu9"
      },
      "source": [
        "\n",
        "# !nvidia-smi"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RVvHsAcjTnxt"
      },
      "source": [
        "🔑 Note: If you have access to a GPU, TensorFlow will automatically use it whenever possible."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iIntG2V9ToUc"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}