tensorflow01.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/girivj/LearningTensor/blob/main/tensorflow01.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ONYhcdSHijM3"
      },
      "source": [
        "# Now I am going to learn Tesorflow Fundamentals"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZgqkwLFJj3I5"
      },
      "source": [
        "# Introduction to Tensors"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hoz_KSkmkfdt",
        "outputId": "13c6056f-8bc8-4bbd-a091-aab100e142ea"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.17.0\n"
          ]
        }
      ],
      "source": [
        "#Import Tensorflow\n",
        "import tensorflow as tf\n",
        "print(tf.__version__)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_HKiL10olhb4",
        "outputId": "0dda7e30-7000-4ea2-b4f5-170c0617af55"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int32, numpy=7>"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "#Creating tensors with tf.constant()\n",
        "scalar = tf.constant(7)\n",
        "scalar"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BqiiYWDxmtud",
        "outputId": "b17e1fca-1290-4339-c277-204a55aab3ab"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "# Check the number of dimensions of a Tensor (ndim stands for number of dimensions)\n",
        "scalar.ndim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1iYHOy-vnTVa",
        "outputId": "2347f928-9cff-4a51-cf18-9405dac6f2fd"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([10, 10], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "#Create a vector\n",
        "vector = tf.constant([10,10])\n",
        "vector"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b8YtaX5inwcj",
        "outputId": "7835cedb-83d9-49b1-eb1d-781eb0c9b249"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "#Checking the Dimensions\n",
        "vector.ndim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rFbmFVkhopVl",
        "outputId": "01f4649b-d21f-4325-cdda-5b237f635573"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3), dtype=int32, numpy=\n",
              "array([[10,  7,  5],\n",
              "       [20,  4,  5]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "#Create a matrix (has more than 1 Dimensions)\n",
        "matrix = tf.constant([[10,7,5],\n",
        "                      [20,4,5]])\n",
        "matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4fHohImwpK-D",
        "outputId": "fc70d4b3-d04b-4dee-d66b-ccbb4980a37c"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ],
      "source": [
        "matrix.ndim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dB9a0CWZqP4R",
        "outputId": "bd8ab626-07db-414f-b2f2-9af698357be0"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=float16, numpy=\n",
              "array([[10.,  2.,  4.],\n",
              "       [ 3.,  5.,  9.],\n",
              "       [12.,  4.,  6.]], dtype=float16)>"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ],
      "source": [
        "another_matrix = tf.constant([[10.,2.,4,],\n",
        "                              [3.,5.,9.],\n",
        "                              [12.,4.,6.]],dtype=tf.float16) # sepecify the data type with dtype parameter\n",
        "another_matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XWWAtFMirD68",
        "outputId": "83569874-6a89-4a9c-fde7-bc9533fa5e86"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ],
      "source": [
        "another_matrix.ndim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_ckX0GqcrNCV",
        "outputId": "da0a9ae7-e188-4023-c375-1e3250628dd8"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2, 3), dtype=int32, numpy=\n",
              "array([[[2, 4, 6],\n",
              "        [4, 5, 7]],\n",
              "\n",
              "       [[1, 4, 6],\n",
              "        [6, 8, 9]],\n",
              "\n",
              "       [[7, 9, 4],\n",
              "        [3, 7, 7]]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ],
      "source": [
        "tensor = tf.constant([[[2,4,6],\n",
        "                       [4,5,7]],\n",
        "                      [[1,4,6],\n",
        "                       [6,8,9]],\n",
        "                      [[7,9,4],\n",
        "                       [3,7,7]]])\n",
        "tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mrb9yaZbzzOH",
        "outputId": "4c8e61cd-0e4c-4df5-e7c5-e270ef68d1b5"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ],
      "source": [
        "tensor.ndim"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QEp6pth-0bty"
      },
      "source": [
        "Learned so far\n",
        "\n",
        "* Scalar: a single number\n",
        "* vector: a number with direction\n",
        "* Matrix: a 2-dimensional array of numbers\n",
        "* Tensor: a n-dimensional array of numbers\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H4ZrvAZ-Z_a2"
      },
      "source": [
        "### Creating tensors with `tf.Variable`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JFjhM7ceaAxh",
        "outputId": "6aa60d63-5b63-44ae-c7e3-c670b84d66d3"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Variable 'Variable:0' shape=(2,) dtype=int32, numpy=array([20, 10], dtype=int32)>,\n",
              " <tf.Tensor: shape=(2,), dtype=int32, numpy=array([20, 10], dtype=int32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ],
      "source": [
        "# Creating the same tensor as seen in `tf.constant'\n",
        "changeable_tensor = tf.Variable([20,10])\n",
        "unchangeable_tensor = tf.constant([20,10])\n",
        "changeable_tensor, unchangeable_tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bAqcJrpTaGJi"
      },
      "outputs": [],
      "source": [
        "# Let's try change one of the elements in changeable_tensor\n",
        "#changeable_tensor[0] = 10\n",
        "#changeable_tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PLwffiqPaY8B",
        "outputId": "d836ff2f-c594-4f88-d992-1687af362dd7"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Variable 'Variable:0' shape=(2,) dtype=int32, numpy=array([10, 10], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ],
      "source": [
        "# How about we try .assign()\n",
        "changeable_tensor[0].assign(10)\n",
        "changeable_tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oC4yxVy8aeg3"
      },
      "outputs": [],
      "source": [
        "# Try this code\n",
        "#unchangeable_tensor[0].assign(10)\n",
        "#unchangeable_tensor"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l6MJGZk-ahoj"
      },
      "source": [
        "### Creating Random Tensors"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "80iFBBXqgMOc"
      },
      "source": [
        "Random tensors are tensors of some arbitrary size which contain random numbers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BAlxrraVg53m",
        "outputId": "4908bbbc-0271-47d7-e13e-e21de28a0911"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              " array([[-0.29604465, -0.21134205],\n",
              "        [ 0.01063002,  1.5165398 ],\n",
              "        [ 0.27305737, -0.29925638]], dtype=float32)>,\n",
              " <tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              " array([[-0.29604465, -0.21134205],\n",
              "        [ 0.01063002,  1.5165398 ],\n",
              "        [ 0.27305737, -0.29925638]], dtype=float32)>,\n",
              " <tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
              " array([[ True,  True],\n",
              "        [ True,  True],\n",
              "        [ True,  True]])>)"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ],
      "source": [
        "random_1 = tf.random.Generator.from_seed(10) #set seed for reproducibility\n",
        "random_1 = random_1.normal(shape=(3,2))\n",
        "random_2 = tf.random.Generator.from_seed(10)\n",
        "random_2 = random_2.normal(shape=(3,2))\n",
        "\n",
        "\n",
        "#Are they Equal ?\n",
        "random_1, random_2, random_1 == random_2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PbucPYiJnIe0"
      },
      "source": [
        "Suffle the order of elements in a tensor"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Shuffle the order of elements in a tensor"
      ],
      "metadata": {
        "id": "h2mG0hpe11km"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Shuffle a tensor\n",
        "not_shuffled = tf.constant([[10, 7],\n",
        "                            [3, 4],\n",
        "                            [2, 5]])\n",
        "not_shuffled.ndim\n",
        "# Shuffle our non-shuffled tensor\n",
        "tf.random.shuffle(not_shuffled)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S0SAXqnLJFLO",
        "outputId": "ae6acf32-b44b-4802-a68a-b687072e202a"
      },
      "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": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.random.set_seed(42)\n",
        "tf.random.shuffle(not_shuffled,seed = 42)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TAXCZz8MV_Gi",
        "outputId": "44a1ac79-b240-4846-8f70-a2e8e404dac8"
      },
      "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": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "not_shuffled"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "msYQSJK1U0Mh",
        "outputId": "6c3726d4-4522-4177-e31c-2111a07d6bcf"
      },
      "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": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.random.set_seed(42) #global level random seed\n",
        "tf.random.shuffle(not_shuffled,seed = 42) #operation level random seed"
      ],
      "metadata": {
        "id": "7iUM72bOU4Vs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a1f36c49-1fd9-4397-d20c-13b7f6788514"
      },
      "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": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Other ways to make tensors"
      ],
      "metadata": {
        "id": "jB1X6ks-a9wV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Creating a tensor of all ones\n",
        "tf.ones([5,6])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h3QK42aHcKN4",
        "outputId": "e9b9d655-012e-4837-b508-1bf330ac281a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(5, 6), dtype=float32, numpy=\n",
              "array([[1., 1., 1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1., 1., 1.]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Creating a tensor of all zeroes\n",
        "tf.zeros(shape=(4,5))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4az3wFJAcc_D",
        "outputId": "268c89f0-5e15-4535-96ce-63ba5301efb7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(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.]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Numpy arrays into tensors"
      ],
      "metadata": {
        "id": "a3jtmZ9rc9-U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "numpy_A = np.arange(1,25,dtype=np.int32)\n",
        "numpy_A"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d7Z2HRq8dZ94",
        "outputId": "c5b40716-6a5c-40f7-e682-439f9dd0c162"
      },
      "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)"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "A = tf.constant(numpy_A)\n",
        "A"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AbtMkiEdd7Ff",
        "outputId": "855fbf0a-7998-4bcc-adb0-508d29272502"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(24,), dtype=int32, numpy=\n",
              "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)>"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "B = tf.constant(numpy_A,shape=(2,3,4))\n",
        "B"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r4pbbEMueVRR",
        "outputId": "9cfb6ecf-dbec-4b09-a736-2ff79719f13e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3, 4), dtype=int32, numpy=\n",
              "array([[[ 1,  2,  3,  4],\n",
              "        [ 5,  6,  7,  8],\n",
              "        [ 9, 10, 11, 12]],\n",
              "\n",
              "       [[13, 14, 15, 16],\n",
              "        [17, 18, 19, 20],\n",
              "        [21, 22, 23, 24]]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "C = tf.constant(numpy_A,shape=(3,8))\n",
        "C"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RMt_H49JeqgM",
        "outputId": "3094b668-135c-4e8d-8e58-7473f7be66ce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 8), dtype=int32, numpy=\n",
              "array([[ 1,  2,  3,  4,  5,  6,  7,  8],\n",
              "       [ 9, 10, 11, 12, 13, 14, 15, 16],\n",
              "       [17, 18, 19, 20, 21, 22, 23, 24]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Getting information from tensors\n",
        " When you are dealing with tensors you probably want to know this attributes\n",
        "* Shape\n",
        "* Rank\n",
        "* Axis or Dimension\n",
        "* Size"
      ],
      "metadata": {
        "id": "YuMvL0VsfVjj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a rank 4 tensor\n",
        "rank_4_tensor = tf.zeros(shape=(2,3,4,5))\n",
        "rank_4_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ajqkGkpqfrTr",
        "outputId": "31e3ff8b-ea84-440c-9a43-d741e643d9ba"
      },
      "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": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rank_4_tensor[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uScQVOGFfxMa",
        "outputId": "c48e3d9b-4fae-4f9f-aa68-180b45fb054c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(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.]]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rank_4_tensor.shape,rank_4_tensor.ndim, tf.size(rank_4_tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g4vKAs6bit0v",
        "outputId": "6534d21e-2cde-432e-9083-28e249a7f60c"
      },
      "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": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Getting  various attributes fo tensor\n",
        "print(\"Datatype of every element \",rank_4_tensor.dtype)\n",
        "print(\"Number of Dimensios (rank) \",rank_4_tensor.ndim)\n",
        "print(\"Shape of tensor \",rank_4_tensor.shape)\n",
        "print(\"Elements along 0 axis \",rank_4_tensor.shape[0])\n",
        "print(\"Elements 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": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "so6jhxUpjEYF",
        "outputId": "875d5101-e9bd-41a6-b0e1-92be3dbfebf6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Datatype of every element  <dtype: 'float32'>\n",
            "Number of Dimensios (rank)  4\n",
            "Shape of tensor  (2, 3, 4, 5)\n",
            "Elements along 0 axis  2\n",
            "Elements along the last axis  5\n",
            "Total number of Elements in our tensor  120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Indexing in Tensors\n",
        "### Indexing in tensors are just like Python indexing"
      ],
      "metadata": {
        "id": "KlTwE4AsuaLZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "rank_4_tensor[:2,:2,:2,:2]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "urM2LoCEf8dc",
        "outputId": "08ee9fde-7370-4507-cce9-7df91b292e24"
      },
      "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": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rank_4_tensor[:1,:1,:1,:]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "efhKr9DLgj87",
        "outputId": "cdcda2f6-ea99-49c6-dcb0-6a0396ae8b4d"
      },
      "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": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rank_2_tensor = tf.constant([[10,7],\n",
        "                             [3,4]])\n",
        "\n",
        "rank_2_tensor.ndim, rank_2_tensor.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MFsO8AbIhqZV",
        "outputId": "a5247afa-c981-4fbc-dc1f-6358663154a5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, TensorShape([2, 2]))"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rank_2_tensor[:,-1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "664Hy8iUiGt8",
        "outputId": "48f9207d-84f4-40ae-db65-a89c1bf94f24"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([7, 4], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rank_2_tensor[-1,:]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VscC2-Gai8_y",
        "outputId": "21f5c26c-256c-4ad4-b009-7996dfa5d4fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([3, 4], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rank_3_tensor = rank_2_tensor[...,tf.newaxis]\n",
        "rank_3_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ed9jVEmIjFYg",
        "outputId": "3b35c071-7833-40fc-b8cc-ffa654979685"
      },
      "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": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.expand_dims(rank_2_tensor,axis=-1) #-1 means expand thw fimal axis"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KOgZVQ9njnSU",
        "outputId": "65e41025-7acb-43f3-f381-b9cf49a7bf59"
      },
      "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": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rank_2_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PiX_pqH9ke4u",
        "outputId": "335d9b34-ceba-48b8-d3e6-0dc3dfb2649c"
      },
      "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": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.expand_dims(rank_2_tensor,axis=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HUhP38v1kjhI",
        "outputId": "063f8c4f-f5d7-4725-a229-5c5b2f3e4848"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(1, 2, 2), dtype=int32, numpy=\n",
              "array([[[10,  7],\n",
              "        [ 3,  4]]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Manipulating tensors (tensor operations)\n",
        "**Basic operations**\n",
        "`+`, `-`,`*`,`/`"
      ],
      "metadata": {
        "id": "iEM3Ahkck8Qr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#You can add values to the tensor using addition operation\n",
        "tensow  = tf.constant([[10,7],[3,4]])\n",
        "tensow * 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7G96mgyUmljX",
        "outputId": "b0ff2312-5ecd-48f8-f477-9123286bfe35"
      },
      "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": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Original tensor will be unchanged\n",
        "tensow"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "beXVDHRhnr2G",
        "outputId": "63667ca5-dfbb-454e-96e1-f6d2a14d3bff"
      },
      "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": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.multiply(rank_2_tensor,3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oRYl_ljAn5DC",
        "outputId": "e7d8eed4-385c-49c0-908f-37de63c74b6c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[30, 21],\n",
              "       [ 9, 12]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Matrix Mulitiplication**"
      ],
      "metadata": {
        "id": "7QbUwSz12NM9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensow)\n",
        "tf.matmul(tensow,tensow)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H9LMnmbs3kqc",
        "outputId": "fe662469-7491-4f17-e422-6d525364ff08"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[10  7]\n",
            " [ 3  4]], shape=(2, 2), dtype=int32)\n"
          ]
        },
        {
          "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": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensow * tensow"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hc5d3_b_5fde",
        "outputId": "c81902c3-a901-4778-9aba-8b6c3f22f4a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[100,  49],\n",
              "       [  9,  16]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Matrix mutiplication with Python Operation \"@\"\n",
        "tensow @ tensow"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O0J9w6vR5KFw",
        "outputId": "242b8126-6cf8-4823-d3ec-3d8f38ed10f5"
      },
      "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": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Create a tensor with (3,2) matrixx\n",
        "X = tf.constant([[1,2],\n",
        "                 [3,4],\n",
        "                 [5,6]])\n",
        "#Create a tensor with (3,2) matrix\n",
        "Y = tf.constant([[7,8],\n",
        "                 [9,10],\n",
        "                 [11,12]])\n",
        "X,Y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TUjZ1RMg5klb",
        "outputId": "51de4750-01d2-4205-b8d5-60de127cda62"
      },
      "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)>,\n",
              " <tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              " array([[ 7,  8],\n",
              "        [ 9, 10],\n",
              "        [11, 12]], dtype=int32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.reshape(Y,shape=(2,3))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2rfaMWeM6pNk",
        "outputId": "3a997247-16e2-4224-a273-c299cdac2e81"
      },
      "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": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X @ tf.reshape(Y,shape=(2,3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hFQDRaIp9CWA",
        "outputId": "26e0ef5d-ba86-4512-eefa-f48bdc9868d4"
      },
      "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": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Try matrix multiplication with matrix transpose instead of reshape\n",
        "tf.matmul(tf.transpose(X),Y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GW_dMxE_9jwl",
        "outputId": "fb64e30a-4644-4fb1-9fcf-5a65807a2a1f"
      },
      "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": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "** The dot Product **\n",
        "\n",
        "Matrix Multiplicationis also referred as dot product.\n",
        "\n",
        "You can matrix multiplication using :\n",
        "* `tf.matmul()`\n",
        "* `tf.tensordot()`"
      ],
      "metadata": {
        "id": "mFil1mDq_fSZ"
      }
    },
    {
      "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/"
        },
        "id": "L9L-5PAwDCuA",
        "outputId": "40f75f09-2e0d-4b3e-cf9e-17c67ecf0d25"
      },
      "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": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Changing the datatype of the tensor"
      ],
      "metadata": {
        "id": "LnQqusQqEDSp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Create the new tensor with default datatype (float32)\n",
        "B = tf.constant([[1.7,7.4]])\n",
        "C = tf.constant([[10,7]])\n",
        "print(B.dtype)\n",
        "C.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dJTfD0oRF5oS",
        "outputId": "4a235d4a-54b0-42a2-920b-1c63dcdaa660"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<dtype: 'float32'>\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tf.int32"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Changing from float32 to float16 (reduced precision)\n",
        "D = tf.cast(B, dtype=tf.float16)\n",
        "D"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D-G23_lxGWtd",
        "outputId": "4ef2694d-b5e7-4279-9235-32a9ea0b922b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(1, 2), dtype=float16, numpy=array([[1.7, 7.4]], dtype=float16)>"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "E = tf.cast(C,dtype=tf.float16)\n",
        "E.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IlwdV7CuHIam",
        "outputId": "cedba66a-c18c-4a76-9e9f-1519712266af"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tf.float16"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Aggregating Tensors\n",
        "\n",
        "Aggreating tensors  = condensing them from multiple values down to a smaller amount of values  "
      ],
      "metadata": {
        "id": "xc32Dhs3H3dZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "D = tf.constant([-7,-10])\n",
        "D"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m2EGZudqJR2s",
        "outputId": "fe7dd242-f854-4d91-fbdb-0748c9fc6738"
      },
      "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": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.abs(D)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h4souVigJhyX",
        "outputId": "41617da1-d1f8-42df-8509-216b19c2fa4d"
      },
      "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": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "F = tf.constant(np.random.randint(1,100,size=40))\n",
        "F"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1hwC-Z9gJlwz",
        "outputId": "f499899b-8f04-4a5c-eec0-83be32fbfef8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(40,), dtype=int64, numpy=\n",
              "array([28, 23, 76, 44, 32, 15, 77, 61, 73, 19, 44, 73, 95, 40, 59, 23, 47,\n",
              "       68, 29, 10, 13,  2, 28, 23, 62, 91, 70, 81, 76, 20, 26, 13, 55, 54,\n",
              "       26, 69, 44, 55, 94, 38])>"
            ]
          },
          "metadata": {},
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.size(F), F.shape, F.ndim,"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kS3b85W1MUiQ",
        "outputId": "9ddf97da-27f0-430c-ebd1-97e4b5cffbe4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(), dtype=int32, numpy=40>, TensorShape([40]), 1)"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.reduce_min(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lRxNPFxRMfgA",
        "outputId": "a6e336cf-040b-40f2-e7e5-644825a19915"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=2>"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.reduce_max(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BgpeTK04M0bR",
        "outputId": "fdaca44a-587b-4f2d-a1dc-18f946f35700"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=95>"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.reduce_mean(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8bkO8ecAM9gh",
        "outputId": "cefaaf34-45c2-4bfd-e887-483177ad0b3d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=46>"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.reduce_sum(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "db7yNrZYNEo0",
        "outputId": "9c8456d9-c94b-4041-d875-fcf9d9568996"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=1876>"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow_probability as tfp"
      ],
      "metadata": {
        "id": "RQiNSkz8NMit"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# To find the variance we need tensor flow probability module\n",
        "tfp.stats.variance(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q-T9HzBDPMhC",
        "outputId": "3e26cd17-c6aa-4e4d-ff2b-8f9ed0d4d4c8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=651>"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.math.reduce_std(tf.cast(F,dtype=tf.float16))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G4VkdJ5cPVSq",
        "outputId": "244e63b6-130b-495e-a37a-cbeb661d65ce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float16, numpy=25.5>"
            ]
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Finding the positional maximum and minimum"
      ],
      "metadata": {
        "id": "yDKtWStrQMX9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a new tensor finding positonal minimum and maximum\n",
        "tf.random.set_seed(42)\n",
        "F = tf.random.uniform(shape=[50])\n",
        "F"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uUY6Uvh8Mc5J",
        "outputId": "b29502ab-eb33-4cd3-c058-b9f1fa6f94e6"
      },
      "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": 67
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.argmax(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aCnhfOrcNXhJ",
        "outputId": "6ad94b12-0942-4fa7-ae63-c0e5ef7d4320"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=42>"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "F[tf.argmax(F)]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5TIRfIBgN8kv",
        "outputId": "f5b57979-367a-452a-d3fc-308c6b498dad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=0.9671384>"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "F[tf.argmax(F)] == tf.reduce_max(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BYuzmYzVONg3",
        "outputId": "61b65944-82e6-424b-ffa0-d0c127fc295e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=bool, numpy=True>"
            ]
          },
          "metadata": {},
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Finding the positional minimum\n",
        "tf.argmin(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dw0AhDU9Oij4",
        "outputId": "0b56613d-b384-4972-f978-6be0e4176b04"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=16>"
            ]
          },
          "metadata": {},
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.reduce_min(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DEyE6yCfPERT",
        "outputId": "53352f10-8276-4b3b-bcc3-f16fc5f78914"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=0.009463668>"
            ]
          },
          "metadata": {},
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Squeezing  a tensor (removing all single dimensions)"
      ],
      "metadata": {
        "id": "17Q_1Rc5PJwM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "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": "gWvGFbLsPwtm",
        "outputId": "5361611f-0254-4d91-803f-dcffc58caed8"
      },
      "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": 80
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "G.shape,G.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I3dM7uaDP5Sq",
        "outputId": "55364926-649c-4c8e-d24d-0decf442b1c7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorShape([1, 1, 1, 1, 50]), 5)"
            ]
          },
          "metadata": {},
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "G_squeezed = tf.squeeze(G)\n",
        "G_squeezed, G_squeezed.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zKUH2Tx_Qk2k",
        "outputId": "02a5beec-3362-428c-9abb-d7a248ce7ad8"
      },
      "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)>,\n",
              " TensorShape([50]))"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " ### One hot encoding  tensors"
      ],
      "metadata": {
        "id": "jSUckkueQy9n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "some_list = [0,1,2,3] #could be any color\n",
        "\n",
        "# One hot encode our list of indices\n",
        "tf.one_hot(some_list,depth=4,on_value=1,off_value=0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kG_1aTXpRSJq",
        "outputId": "a0d18327-7612-4418-fb00-e2a14b92c002"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(4, 4), dtype=int32, numpy=\n",
              "array([[1, 0, 0, 0],\n",
              "       [0, 1, 0, 0],\n",
              "       [0, 0, 1, 0],\n",
              "       [0, 0, 0, 1]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Squaring, log, square root\n",
        "H = tf.range(1,10)\n",
        "H"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ItHfVGNHSC0f",
        "outputId": "2a2e0dc5-905e-4870-8fd3-4d05d8a6ce89"
      },
      "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": 89
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.square(H)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F5pHU8DRWHYY",
        "outputId": "056497cb-b01e-41ab-8b12-8108d8d43bf7"
      },
      "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": 90
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.sqrt(tf.cast(H,dtype=tf.float32))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zC2EAr_0WNEj",
        "outputId": "b39ad355-2357-4b26-ffac-8561a0fbb73e"
      },
      "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.236068 , 2.4494898,\n",
              "       2.6457512, 2.828427 , 3.       ], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.math.log(tf.cast(H,dtype=tf.float32))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aGjqvUDPWXzr",
        "outputId": "5330b373-fd40-40d4-9fa3-3c2e6a9c15e5"
      },
      "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": 98
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Tensors and Numpy\n",
        "\n",
        "TensorFlow interacts beautiully with Numpy arrays"
      ],
      "metadata": {
        "id": "_21eJlH3XKSc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "J = tf.constant(np.array([3.,7.,10.]))\n",
        "J"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-mzmkXmoZZ4K",
        "outputId": "ff4481b7-ffbf-4274-9117-dae8a22c41f1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=float64, numpy=array([ 3.,  7., 10.])>"
            ]
          },
          "metadata": {},
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.array(J), type(np.array(J))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "se-jpcnOaddT",
        "outputId": "a4a3356e-880e-4542-e873-3d65e73822ee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([ 3.,  7., 10.]), numpy.ndarray)"
            ]
          },
          "metadata": {},
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## Convert tensor J to a numpy array\n",
        "J.numpy(), type(J.numpy())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hXEGHKdravm0",
        "outputId": "992ee00b-5c4a-44a8-80ed-23f88f4b63ea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([ 3.,  7., 10.]), numpy.ndarray)"
            ]
          },
          "metadata": {},
          "execution_count": 103
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "J = tf.constant([3.])\n",
        "J.numpy()[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fzYThkwPbDc_",
        "outputId": "ebbe9885-9233-40b4-f890-da6fc6c29123"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.0"
            ]
          },
          "metadata": {},
          "execution_count": 105
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Tensor_J = tf.constant([3.,7.,10.])\n",
        "Numpy_J = tf.constant(np.array([3.,7.,10.]))\n",
        "Tensor_J.dtype,Numpy_J.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XLFX0sQUbWIl",
        "outputId": "c0e01f24-aa14-4795-e273-82c78612331a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tf.float32, tf.float64)"
            ]
          },
          "metadata": {},
          "execution_count": 107
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "tf.config.list_physical_devices('GPU')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0VfX965YcI8c",
        "outputId": "43492e58-1976-49e8-fad2-fdcbf8b3304d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!nvidia-smi"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wGjEBz49eitD",
        "outputId": "2ea340d4-b66f-4c88-abdb-11cec75fc078"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sun Nov  3 14:53:26 2024       \n",
            "+---------------------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 535.104.05             Driver Version: 535.104.05   CUDA Version: 12.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   47C    P8              12W /  70W |      3MiB / 15360MiB |      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",
            "|  No running processes found                                                           |\n",
            "+---------------------------------------------------------------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "mGhlSOmGhD0Z"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyNKVKiKbCqWOt45tAOlJsFD",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}