00_tensorflow_fundamentals.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "b8fTQubx5igo",
        "H_P5JYVv7lUm",
        "yEYC5gpDgldY",
        "Lr-QeRaX58-8",
        "KehD_xov7EI7",
        "kb7GbKkk81gi",
        "coz8otAkjpx2"
      ],
      "authorship_tag": "ABX9TyMX3EosGZI1ETMer1w/E3hn",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AlexandreLarget/tensorflow_certification_training/blob/main/00_tensorflow_fundamentals.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# In this notebook, we're going to cover some of the most fundamental cooncepts of tensors using tensorflow\n",
        "\n",
        "More specifically, we're going to cover :\n",
        "* Introduction to tensors\n",
        "* Getting information from tensors\n",
        "* Manipulating tensors\n",
        "* Tensors & NumPy\n",
        "* Using @tf.function (a way to speed up your regular Python functions)\n",
        "* Using GPUs with Tensorflow (or TPUs)\n",
        "* Exercices to try yourself"
      ],
      "metadata": {
        "id": "WIbpuPeZyhnS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Introduction to tensors "
      ],
      "metadata": {
        "id": "vXM_3OIyzYfd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import Tensorflow\n",
        "import tensorflow as tf\n",
        "print(tf.__version__)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DAJLpJRO0E5k",
        "outputId": "dfb72770-7e61-436a-a3ba-e02f8a485f4b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.8.2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create tensors with tf.constant()\n",
        "scalar = tf.constant(7)\n",
        "scalar"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ipVYofAA0NQY",
        "outputId": "2165010c-1766-4045-d9d6-3eef03adc5ae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int32, numpy=7>"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check the number of dimensions of a tensor (ndim)\n",
        "scalar.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1FLSEmW-0yUS",
        "outputId": "c2161b28-9cbf-4fd7-f2a9-d8413fff1322"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a vector\n",
        "vector = tf.constant([10,10])\n",
        "vector"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4jViWdbA1M0W",
        "outputId": "e233ae8c-843c-4ec3-e3bf-ea6a52648988"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([10, 10], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check the dimension ofour vector\n",
        "vector.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wybdpc3Y1WhE",
        "outputId": "62dbb377-3a5a-42cc-eded-6dc44cdfce9f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a matrix (more than 1 dimension)\n",
        "matrix = tf.constant([[10,7],\n",
        "                      [7,10]])\n",
        "matrix"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x1X9PaBQ1gy4",
        "outputId": "b131cbfd-e674-43de-e8cf-57f82d6286c0"
      },
      "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": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "matrix.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r7SAe11i1u-9",
        "outputId": "59cf4d81-d38a-4f0a-9d66-8eed395ad21b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create another matrix\n",
        "another_matrix = tf.constant([[10.,7.],\n",
        "                              [3., 2.],\n",
        "                              [8.,9.]], dtype=tf.float16) #specify the data type \n",
        "another_matrix"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HLklPf2c1w7Z",
        "outputId": "6706a67b-a000-43f1-8c9c-4bfbe867702c"
      },
      "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": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "another_matrix.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ny9I1j1V2wsx",
        "outputId": "b43e6e25-11bd-421c-9870-c97fc649e904"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's create a tensor\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",
        "tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S7iZQDFu3B2M",
        "outputId": "dce15151-8f97-4448-d0e1-d7374edf6817"
      },
      "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": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n-0jZast4gk-",
        "outputId": "608c8dfa-9af7-471a-866f-57296d7822df"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "What we've created so far :\n",
        "* Scalar : a single number\n",
        "* Vector : a number with direction (e.g. wind speed and direction)\n",
        "* Matrix : a 2-dimensional array of numbers\n",
        "* Tensor : an n-dimensional array of numbers"
      ],
      "metadata": {
        "id": "MAewk-QW4kwn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating ensors with `tf.Varaible`"
      ],
      "metadata": {
        "id": "b8fTQubx5igo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the same tensor with tf.Variable()\n",
        "changeable_tensor = tf.Variable([10, 7])\n",
        "unchangeable_tensor = tf.constant([10, 7])\n",
        "changeable_tensor, unchangeable_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VP6ynV0j57iA",
        "outputId": "5359fa25-6aab-4bb4-ee94-7a9f708bdc7a"
      },
      "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": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's try to change one of the elements in our changeable tensor\n",
        "changeable_tensor[0] = 7\n",
        "changeable_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 205
        },
        "id": "_gCAJSmX6tp0",
        "outputId": "4a0644bc-8fbe-4287-fbcb-0a38b8217312"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-13-9972a815a90d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Let's try to change one of the elements in our changeable tensor\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[0mchangeable_tensor\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m7\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mchangeable_tensor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: 'ResourceVariable' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# How about we try .assign()\n",
        "changeable_tensor[0].assign(7)\n",
        "changeable_tensor"
      ],
      "metadata": {
        "id": "8GzIkidK7CA6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's try to change our unchangeable tensor\n",
        "unchangeable_tensor[0] = 7\n",
        "unchangeable_tensor"
      ],
      "metadata": {
        "id": "faSgfnYb7O_2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "unchangeable_tensor[0].assign(7)\n",
        "unchangeable_tensor"
      ],
      "metadata": {
        "id": "iAMgL-9W7gNE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "🔑 **Note**: Rarely in practice will you need to decide wheter to use `tf.constant` or `tf.Variable` to create tensors. TF will choose for you.\n",
        "However, if in doubt, use `tf.constant` and change it later if needed."
      ],
      "metadata": {
        "id": "TAXl444-dqX1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating random tensors\n",
        "\n",
        "Random tensors are tensors of some arbitrary size which contain random numbers."
      ],
      "metadata": {
        "id": "H_P5JYVv7lUm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create two random (but the same) tensors\n",
        "random_1 = tf.random.Generator.from_seed(42)\n",
        "random_1 = random_1.normal(shape=(3,2))\n",
        "random_1"
      ],
      "metadata": {
        "id": "5UKgGwiid0N9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "random_2 = tf.random.Generator.from_seed(42)\n",
        "random_2 = random_2.normal(shape=(3,2))\n",
        "random_2"
      ],
      "metadata": {
        "id": "q-ozEWIufYPZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "random_1 == random_2"
      ],
      "metadata": {
        "id": "UB94yx5IgOUf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "random_3 = tf.random.Generator.from_seed(7)\n",
        "random_3 = random_3.normal(shape=(3,2))\n",
        "random_3"
      ],
      "metadata": {
        "id": "5ChOh5fqgQw8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Shuffle the order of elements in a tensor"
      ],
      "metadata": {
        "id": "yEYC5gpDgldY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Shuffle a tensor (valuable for when you want to shuffle your data so the inherent order doesn't affect your learning)\n",
        "not_shuffled = tf.constant([[10,7],\n",
        "                            [3,4],\n",
        "                            [2,5]])\n",
        "not_shuffled.ndim"
      ],
      "metadata": {
        "id": "mZrDZI1ehYlW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "not_shuffled"
      ],
      "metadata": {
        "id": "wS7tCpYTiT4g"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Shuffle our non-shiffled tensor\n",
        "tf.random.shuffle(not_shuffled)"
      ],
      "metadata": {
        "id": "_7hAVcGSiPlF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# random seed global & operation level\n",
        "tf.random.set_seed(42) # global level rando  seed\n",
        "tf.random.shuffle(not_shuffled, seed=42) # operation level random seed"
      ],
      "metadata": {
        "id": "9ln8g1r8ixia"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Other ways to make tensors"
      ],
      "metadata": {
        "id": "Lr-QeRaX58-8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensos of all ones\n",
        "tf.ones([10,7])"
      ],
      "metadata": {
        "id": "d7ALvnFq6fNv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensor of all zeros\n",
        "tf.zeros(shape=(3,4))"
      ],
      "metadata": {
        "id": "x_qX6_gf68rA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Turn NumPy arrays into tensors\n",
        "\n",
        "The main difference between NumPy arrays and TensorFlows tensors is that tensors can be run on a GPU."
      ],
      "metadata": {
        "id": "KehD_xov7EI7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "numpy_A = np.arange(1,25, dtype=np.int32)\n",
        "numpy_A"
      ],
      "metadata": {
        "id": "1DhNd5a37kk8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tf.constant(numpy_A)"
      ],
      "metadata": {
        "id": "5GiLlNjl8inJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tf.constant(numpy_A, shape=(4,2,3))"
      ],
      "metadata": {
        "id": "obomFXN98Ces"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "4*2*3"
      ],
      "metadata": {
        "id": "5qF22gih8OE8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Getting information from tensors\n",
        "\n",
        "* Shape\n",
        "* Rank\n",
        "* Axis or dimension\n",
        "* Size"
      ],
      "metadata": {
        "id": "kb7GbKkk81gi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a rank 4 tensor\n",
        "rank_4_tensor = tf.zeros(shape=(2,3,4,5))\n",
        "rank_4_tensor"
      ],
      "metadata": {
        "id": "JLg5DRRF-Qva"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        " rank_4_tensor[0]"
      ],
      "metadata": {
        "id": "WgzmS-YU9LtX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rank_4_tensor.shape, rank_4_tensor.ndim, tf.size(rank_4_tensor) "
      ],
      "metadata": {
        "id": "au4UFFcM_ILI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "2*3*4*5"
      ],
      "metadata": {
        "id": "DZI6_fCj_XzD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Element along the 0 axis:\", rank_4_tensor.shape[0])\n",
        "print(\"Element along the last axis:\", rank_4_tensor.shape[-1])\n",
        "print(\"Total number of elements in our tensor:\", tf.size(rank_4_tensor).numpy())"
      ],
      "metadata": {
        "id": "1MGbewqP_dDk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Indexing tensors\n",
        "\n",
        "Tensors can be indexed just Pyhton lists."
      ],
      "metadata": {
        "id": "coz8otAkjpx2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "some_list = [1,2,3,4]\n",
        "some_list[:2]"
      ],
      "metadata": {
        "id": "8zDLmsoHkF--"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the first 2 elements of each dimension\n",
        "rank_4_tensor[:2, :2, :2, :2]"
      ],
      "metadata": {
        "id": "cfcobRlWki_D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a rank 2 tensor (2 dimensions)\n",
        "rank_2_tensor = tf.constant([[10,7], [3,4]])\n",
        "rank_2_tensor"
      ],
      "metadata": {
        "id": "Thq-aH3vkn1S"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rank_2_tensor.ndim"
      ],
      "metadata": {
        "id": "jlnz44Nilwts"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the last item of each rows:\n",
        "rank_2_tensor[:,-1]"
      ],
      "metadata": {
        "id": "7bjyvwe7lzxS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Add in extra dimension to our rank 2 tensor\n",
        "rank_3_tensor = rank_2_tensor[..., tf.newaxis]\n",
        "rank_3_tensor"
      ],
      "metadata": {
        "id": "IKMLSOrMmSJO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Alternstive to tf.newaxis\n",
        "tf.expand_dims(rank_2_tensor, axis=-1)"
      ],
      "metadata": {
        "id": "5sJ_1eDKmMRK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tf.expand_dims(rank_2_tensor, axis=0)"
      ],
      "metadata": {
        "id": "uL1wX4d6nk8I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tf.expand_dims(rank_2_tensor, axis=1)"
      ],
      "metadata": {
        "id": "cN6V_wBEnw9u"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Manipulating tensors (tensor operations)\n",
        "\n",
        "**Basic operations**\n",
        "\n",
        "`+`, `-`, `*`, `/`"
      ],
      "metadata": {
        "id": "JOqDvjz6n0TN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# You can add values to a tensor using the addition operator\n",
        "tensor = tf.constant([[10, 7], [3, 4]])\n",
        "tensor + 10"
      ],
      "metadata": {
        "id": "gcCRP1nKoeD8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiplication\n",
        "tensor * 10"
      ],
      "metadata": {
        "id": "OxzVymFYpJ7A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# We can use the tensorflow built-in function too\n",
        "tf.multiply(tensor, 10)"
      ],
      "metadata": {
        "id": "alrLCVk1pRaX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Matrix multiplication**\n",
        "\n",
        "In machine learning, matrix multiplication is one of the most common tensor operations.\n",
        "\n",
        "There are two rules our tensors need to fulfil if we're going to matrix multiply them:\n",
        "\n",
        "1. The inner dimensions must match\n",
        "2. The resulting matrix has the shape of the outer dimensions"
      ],
      "metadata": {
        "id": "IDLCW1z9pkNI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "  # Matrix multiplication in tensorflow\n",
        "  print(tensor)\n",
        "  tf.matmul(tensor, tensor)"
      ],
      "metadata": {
        "id": "0IJ0f18cqKva"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        " tensor * tensor"
      ],
      "metadata": {
        "id": "ImPxFEhsrvt3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "matrix_1 = tf.constant([[1, 2, 5], [7, 2, 1], [3, 3, 3]])\n",
        "matrix_2 = tf.constant([[3, 5], [6, 7], [1, 8]])\n",
        "print(matrix_1)\n",
        "print(matrix_2)\n",
        "print(tf.matmul(matrix_1, matrix_2))"
      ],
      "metadata": {
        "id": "uvWYfwDMr6-m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Matrix mutiplication with Python operator \"@\"\n",
        "tensor @ tensor"
      ],
      "metadata": {
        "id": "UzQ-w7HrscBt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Try to multiply tensors of the same shape\n",
        "X = tf.constant([[1, 2], \n",
        "                 [3, 4],\n",
        "                 [5, 6]])\n",
        "Y = tf.constant([[7, 8],\n",
        "                 [9, 10],\n",
        "                 [11, 12]])\n",
        "print(X)\n",
        "print(Y)\n",
        "\n",
        "X @ Y"
      ],
      "metadata": {
        "id": "wj3Wqy9dso1Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "📖 **Ressouce:** Info and example for matrix multiplication https://www.mathsisfun.com/algebra/matrix-multiplying.html"
      ],
      "metadata": {
        "id": "-AscnJ6otiJM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's change the shape of Y\n",
        "tf.reshape(Y, shape=(2, 3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "id": "Svji82kAuQjT",
        "outputId": "7786ff0c-31aa-4523-ac57-b43cff4934ca"
      },
      "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-14-9e59ed0d5b84>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Let's change the shape of Y\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[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\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[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'Y' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Try to matrix multiply X by reshape Y\n",
        "X @ tf.reshape(Y, shape=(2,3))"
      ],
      "metadata": {
        "id": "kmwOfPctyEtr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's change the shape of X instead\n",
        "tf.matmul(tf.reshape(X, shape=(2, 3)), Y)"
      ],
      "metadata": {
        "id": "og9PCLYTybfs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Transpose is slightly different\n",
        "tf.transpose(X), tf.reshape(X, shape=(2, 3))"
      ],
      "metadata": {
        "id": "x7-4TBouy0sp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**The dot product**\n",
        "\n",
        "Matrix multiplication is also referred to as the dot product.\n",
        "\n",
        "You can perform matrix multiplication using:\n",
        "* `tf.matmul()`\n",
        "* `tf.tensordot()`"
      ],
      "metadata": {
        "id": "U-h1SC_zzqcY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Perform the dot product on X and Y \n",
        "tf.tensordot(tf.transpose(X), Y, axes=1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "id": "C4fZji_65egR",
        "outputId": "9a5a0530-fc2e-4380-97f2-cce13f06e2db"
      },
      "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-027936640acb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Perform the dot product on X and Y\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[0mtensordot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'X' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Perform matrix multiplication between X and Y transposed\n",
        "tf.matmul(X, tf.transpose(Y))"
      ],
      "metadata": {
        "id": "OA98z9cg5-Xw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Generally, when performing matrix multiplication on 2 tensors and one of the axes doesn't line up. You will transpose (rather than reshape) one the tensor to satisfy the matrix multiplication rules."
      ],
      "metadata": {
        "id": "GkFwv0HC6tPj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Changing the data type of a tensor"
      ],
      "metadata": {
        "id": "yKvvj2Un8NCj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a new tensor with default datatype (float32)\n",
        "B = tf.constant([1.7, 7.4])\n",
        "B.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l6QDcRuw8ey8",
        "outputId": "1465813e-5cdb-439d-9340-5c1013498ed3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tf.float32"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "C = tf.constant([7, 10])\n",
        "C.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TXa4jefE9AVp",
        "outputId": "36bac653-be4d-4807-8ad9-588b276e1f96"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tf.int32"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Change from float32 to float16 (reduce precision)\n",
        "D = tf.cast(B, dtype=tf.float16)\n",
        "D"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SXbkipeV9G-a",
        "outputId": "ab0515e5-9c83-4564-d5a6-745ce2cb26d1"
      },
      "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": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Change from int32 to float16\n",
        "E = tf.cast(C, dtype=tf.float16)\n",
        "E"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iD-SGaob93mC",
        "outputId": "f9062f03-c474-452f-c0c0-2cff1af6d539"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=float16, numpy=array([ 7., 10.], dtype=float16)>"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Aggregating tensors\n",
        "\n",
        "Aggreagting tensors = condensing them from multiple values down to a smaller amount of values."
      ],
      "metadata": {
        "id": "y9UQVEwg-V90"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the absolute values\n",
        "D = tf.constant([-7, -10])\n",
        "tf.abs(D)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0OdEIw0v_iRV",
        "outputId": "1a1486b3-a01a-4521-9bd3-d7980c528d2c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([ 7, 10], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's go through the following forms of aggregation:\n",
        "* Get the minimum\n",
        "* Get the maximum\n",
        "* Get the mean of a tensor\n",
        "* Get the sum of a tensor"
      ],
      "metadata": {
        "id": "wC9v-kbhAjrI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a random tensor with values between 0 and 100 of size 50\n",
        "E = tf.constant(np.random.randint(0, 100, size=50))\n",
        "E"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 205
        },
        "id": "XpXBOmO-A_4z",
        "outputId": "b8e455e6-f30e-47a3-cfc5-58098d1ca6b0"
      },
      "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-21-2357b4cd9b2a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Create a random tensor with values between 0 and 100 of size 50\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[0mE\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconstant\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m50\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[0m\u001b[1;32m      3\u001b[0m \u001b[0mE\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.size(E), E.shape, E.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZQe0uyD0BZTq",
        "outputId": "842bab58-37f6-4818-cc1c-9d42e99b6e97"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(), dtype=int32, numpy=2>, TensorShape([2]), 1)"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the minimum\n",
        "tf.reduce_min(E)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R-5NHImTBfhm",
        "outputId": "db0f8de2-4d81-43ab-b4f4-09679fb26034"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float16, numpy=7.0>"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the maximum\n",
        "tf.reduce_max(E)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SBvfkpW_B0ln",
        "outputId": "44fe962e-6770-4e13-8ac3-345b7853208d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float16, numpy=10.0>"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the mean\n",
        "tf.reduce_mean(E)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XVJnCVcwB8kc",
        "outputId": "140755bc-592d-4a9b-d1b4-e630914d1fe3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float16, numpy=8.5>"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the sum\n",
        "tf.reduce_sum(E)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e6R7ZyxrCCSP",
        "outputId": "844e0434-9a05-49ce-8ebb-b8e58a8af433"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float16, numpy=17.0>"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow_probability as tfp\n",
        "# Find the variance\n",
        "tfp.stats.variance(E)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YlW6KWI6CFX5",
        "outputId": "0aaa5537-1df2-4866-ccab-10e7c57acad6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float16, numpy=2.25>"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the standard deviation\n",
        "tfp.stats.stddev(tf.cast(E, dtype=tf.float32))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MiS6cuy8Cgf1",
        "outputId": "02991ddb-cec8-47f1-a9ff-2e0238ca3f19"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=1.5>"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.math.reduce_std(tf.cast(E, dtype=tf.float32))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R78ElVoUC47r",
        "outputId": "79058b31-a9bf-4619-d748-22d4f61af0b1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=1.5>"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Find the positional maximum and minimum"
      ],
      "metadata": {
        "id": "klj-toSOFKk6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a new tensor for finding positional min and max\n",
        "tf.random.set_seed(42)\n",
        "F = tf.random.uniform(shape=[50])\n",
        "F"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qCkPpRk5i66I",
        "outputId": "c4972d07-4ee4-4e06-ab1d-efa3c28aeec2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(50,), dtype=float32, numpy=\n",
              "array([0.6645621 , 0.44100678, 0.3528825 , 0.46448255, 0.03366041,\n",
              "       0.68467236, 0.74011743, 0.8724445 , 0.22632635, 0.22319686,\n",
              "       0.3103881 , 0.7223358 , 0.13318717, 0.5480639 , 0.5746088 ,\n",
              "       0.8996835 , 0.00946367, 0.5212307 , 0.6345445 , 0.1993283 ,\n",
              "       0.72942245, 0.54583454, 0.10756552, 0.6767061 , 0.6602763 ,\n",
              "       0.33695042, 0.60141766, 0.21062577, 0.8527372 , 0.44062173,\n",
              "       0.9485276 , 0.23752594, 0.81179297, 0.5263394 , 0.494308  ,\n",
              "       0.21612847, 0.8457197 , 0.8718841 , 0.3083862 , 0.6868038 ,\n",
              "       0.23764038, 0.7817228 , 0.9671384 , 0.06870162, 0.79873943,\n",
              "       0.66028714, 0.5871513 , 0.16461694, 0.7381023 , 0.32054043],\n",
              "      dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the positional max\n",
        "tf.argmax(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ox37uPmZkRBv",
        "outputId": "2d0a7837-8696-4b82-ac49-1be59879c1b6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=42>"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "F[tf.argmax(F)]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZmcdLbFMktvY",
        "outputId": "fd8bfca5-8d82-406f-e785-b65c5dd38c20"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=0.9671384>"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.reduce_max(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yFKeiS0okyKZ",
        "outputId": "d3442643-a79e-4911-9f89-f72f4b0c4dd6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=0.9671384>"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the positional min\n",
        "tf.argmin(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QTI3f3GhkiPF",
        "outputId": "4bbdc943-386a-4876-b0ed-8ff1fc491eaa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=16>"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "F[tf.argmin(F)], tf.reduce_min(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qEkINY1MknaH",
        "outputId": "d005601b-373f-460f-a955-225b4853e2bf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(), dtype=float32, numpy=0.009463668>,\n",
              " <tf.Tensor: shape=(), dtype=float32, numpy=0.009463668>)"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Squeezing a tensor (removing all single dimensions)"
      ],
      "metadata": {
        "id": "AMiZsZ34lQfr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensor to get started\n",
        "tf.random.set_seed(42)\n",
        "G = tf.constant(tf.random.uniform(shape=[50]), shape=(1, 1, 1, 1, 50))\n",
        "G"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Sdfc7RF_leWz",
        "outputId": "1312f489-166f-40bf-8582-dbd527de8a0d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(1, 1, 1, 1, 50), dtype=float32, numpy=\n",
              "array([[[[[0.6645621 , 0.44100678, 0.3528825 , 0.46448255, 0.03366041,\n",
              "           0.68467236, 0.74011743, 0.8724445 , 0.22632635, 0.22319686,\n",
              "           0.3103881 , 0.7223358 , 0.13318717, 0.5480639 , 0.5746088 ,\n",
              "           0.8996835 , 0.00946367, 0.5212307 , 0.6345445 , 0.1993283 ,\n",
              "           0.72942245, 0.54583454, 0.10756552, 0.6767061 , 0.6602763 ,\n",
              "           0.33695042, 0.60141766, 0.21062577, 0.8527372 , 0.44062173,\n",
              "           0.9485276 , 0.23752594, 0.81179297, 0.5263394 , 0.494308  ,\n",
              "           0.21612847, 0.8457197 , 0.8718841 , 0.3083862 , 0.6868038 ,\n",
              "           0.23764038, 0.7817228 , 0.9671384 , 0.06870162, 0.79873943,\n",
              "           0.66028714, 0.5871513 , 0.16461694, 0.7381023 , 0.32054043]]]]],\n",
              "      dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "G.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OENE8JhAlqk5",
        "outputId": "abed3bfc-20d3-4026-9d51-dd904b50b50e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "TensorShape([1, 1, 1, 1, 50])"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "G_squeezed = tf.squeeze(G)\n",
        "G_squeezed, G_squeezed.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jZNp_TErl18A",
        "outputId": "bfefb32a-ed0e-49e0-b46f-34fd1f574b43"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(50,), dtype=float32, numpy=\n",
              " array([0.6645621 , 0.44100678, 0.3528825 , 0.46448255, 0.03366041,\n",
              "        0.68467236, 0.74011743, 0.8724445 , 0.22632635, 0.22319686,\n",
              "        0.3103881 , 0.7223358 , 0.13318717, 0.5480639 , 0.5746088 ,\n",
              "        0.8996835 , 0.00946367, 0.5212307 , 0.6345445 , 0.1993283 ,\n",
              "        0.72942245, 0.54583454, 0.10756552, 0.6767061 , 0.6602763 ,\n",
              "        0.33695042, 0.60141766, 0.21062577, 0.8527372 , 0.44062173,\n",
              "        0.9485276 , 0.23752594, 0.81179297, 0.5263394 , 0.494308  ,\n",
              "        0.21612847, 0.8457197 , 0.8718841 , 0.3083862 , 0.6868038 ,\n",
              "        0.23764038, 0.7817228 , 0.9671384 , 0.06870162, 0.79873943,\n",
              "        0.66028714, 0.5871513 , 0.16461694, 0.7381023 , 0.32054043],\n",
              "       dtype=float32)>, TensorShape([50]))"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### One-hot encoding tensors"
      ],
      "metadata": {
        "id": "2pBgmb8FmJ7n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a list of indices\n",
        "some_list = [0, 1, 2, 3] # could be red, green, blue, yellow\n",
        "\n",
        "# One hot encode our list of indices\n",
        "tf.one_hot(some_list, depth=4)\n",
        " "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t8kmT7_Pl584",
        "outputId": "7d12c587-8645-4328-d906-92288314bf7a"
      },
      "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": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Specify custom values for one hot encoding\n",
        "tf.one_hot(some_list, depth=4, on_value='I love ML', off_value=\"I don't\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UH_urcvHnRob",
        "outputId": "fab85e4e-e7dc-4f17-bd24-1c9fd19ecd07"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(4, 4), dtype=string, numpy=\n",
              "array([[b'I love ML', b\"I don't\", b\"I don't\", b\"I don't\"],\n",
              "       [b\"I don't\", b'I love ML', b\"I don't\", b\"I don't\"],\n",
              "       [b\"I don't\", b\"I don't\", b'I love ML', b\"I don't\"],\n",
              "       [b\"I don't\", b\"I don't\", b\"I don't\", b'I love ML']], dtype=object)>"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Squaring, log, square root"
      ],
      "metadata": {
        "id": "2JO8FFE1nwYu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "H = tf.range(1, 10)\n",
        "H"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qXGh-hESoTMh",
        "outputId": "4d852732-1976-45df-e37e-980ffa9330d3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(9,), dtype=int32, numpy=array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.square(H)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pFER7LkAoace",
        "outputId": "45f16c0a-bab8-46a5-c2be-61774df0042c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(9,), dtype=int32, numpy=array([ 1,  4,  9, 16, 25, 36, 49, 64, 81], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the square root\n",
        "tf.sqrt(tf.cast(H, dtype=tf.float32))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Drt7jAxtoeQ6",
        "outputId": "879d0a69-2019-414d-f94e-d2650269c32e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(9,), dtype=float32, numpy=\n",
              "array([1.       , 1.4142135, 1.7320508, 2.       , 2.2360678, 2.4494896,\n",
              "       2.6457512, 2.828427 , 3.       ], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the log\n",
        "tf.math.log(tf.cast(H, dtype=tf.float32))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YNFkmzGZomys",
        "outputId": "ff4f1441-37d8-4b16-e9ba-5a79228966c7"
      },
      "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": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Tensors and NumPy\n",
        "\n",
        "Tensorflows interacts beautifully with NumPy arrays.\n",
        "\n"
      ],
      "metadata": {
        "id": "v_o3o2x0o8gH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        " # Create a tensor directly from a NumPy array\n",
        " J = tf.constant(np.array([3., 7., 10.]))\n",
        " J"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 205
        },
        "id": "FBI7rtEOp5N5",
        "outputId": "29dab671-be93-47a4-b036-ab2a6eaa4e0f"
      },
      "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-45-9296a6df837a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Create a tensor directly from a NumPy array\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[0mJ\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconstant\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3.\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m7.\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10.\u001b[0m\u001b[0;34m]\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[0m\u001b[1;32m      3\u001b[0m \u001b[0mJ\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert our tensor back to a NumPy array\n",
        "np.array(J), type(np.array(J))"
      ],
      "metadata": {
        "id": "24OMpaZmqc7e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "J.numpy()[0], J.numpy()[1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 169
        },
        "id": "7rXJwtjqqk7c",
        "outputId": "f1012858-f2a7-4008-efd3-c52b7be42d7e"
      },
      "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-46-04aad8604fec>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mJ\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mJ\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'J' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# The default type of each are slightly different\n",
        "numpy_J = tf.constant(np.array([3., 7., 10.]))\n",
        "tensor_J = tf.constant([3., 7., 10.])\n",
        "\n",
        "# Check the datatype of each\n",
        "numpy_J.dtype, tensor_J.dtype"
      ],
      "metadata": {
        "id": "Y9t8VQHuq3tp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Finding acces to GPUs"
      ],
      "metadata": {
        "id": "Lj9d9D6NrZAs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.config.list_physical_devices()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PDF4_4BTsV-Q",
        "outputId": "b22d9f1c-ce3e-4f17-97b5-115f25eebc11"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[PhysicalDevice(name='/physical_device:CPU:0', device_type='CPU'),\n",
              " PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.config.list_physical_devices(\"GPU\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y6QbofOispSy",
        "outputId": "ffbd7f90-8cc2-4467-f1d3-e8d8e1f85dd9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!nvidia-smi"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6r7g3O98tJlu",
        "outputId": "03e96dc9-3f30-4a97-a082-e178422d4e02"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Thu Jun  9 07:48:57 2022       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 460.32.03    Driver Version: 460.32.03    CUDA Version: 11.2     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   62C    P0    31W /  70W |    266MiB / 15109MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "+-----------------------------------------------------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "**Note:"
      ],
      "metadata": {
        "id": "-ctAz2-IuJ4E"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}