Tensors_And_Variables.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyMLd2t0zlqzNDB1jsNPIELK",
      "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/ImanNoferesti/TensorFlow_DeepDive/blob/main/Tensors_And_Variables.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "F5CZFRAjlInw"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Basics"
      ],
      "metadata": {
        "id": "ZRF3w7I47qjl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A 0-dimensional tensor, or scalar, is a single numerical value without any dimensions."
      ],
      "metadata": {
        "id": "7YoLyXMZl3m7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_zero_d = tf.constant(4)\n",
        "print(tensor_zero_d)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TCtjPGM3leXf",
        "outputId": "0249f354-5bf0-4d7d-fffe-94197872a1f2"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(4, shape=(), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A 1-dimensional tensor, or vector, is an array of numerical values arranged in a single line, representing a list of elements.\n",
        "\n",
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "OcireffgmUVG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_one_d = tf.constant([1,2,3])\n",
        "print(tensor_one_d)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xa7FcafOl6JR",
        "outputId": "e19b882a-578b-45d3-c1d4-3dd35169b224"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([1 2 3], shape=(3,), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A 2-dimensional tensor, or matrix, is an array of numerical values arranged in rows and columns, representing a grid of elements.\n",
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "UWAcgXrypPBp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_two_d = tf.constant([\n",
        "    [1,2,0],\n",
        "    [3,5,-1],\n",
        "    [1,5,6],\n",
        "    [2,3,8]\n",
        "])\n",
        "print(tensor_two_d)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6DfDrOYrpQxF",
        "outputId": "3a560fae-f068-452c-99b5-cb35384a8627"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]\n",
            " [ 1  5  6]\n",
            " [ 2  3  8]], shape=(4, 3), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A 3-dimensional tensor is an array of numerical values arranged in multiple matrices, representing a cube of elements.\n",
        "\n",
        "![image.png](data:image/png;base64,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)\n"
      ],
      "metadata": {
        "id": "zxBQIXK9p6R3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_three_d = tf.constant([\n",
        "    [[1,2,0],\n",
        "     [3,5,-1]],\n",
        "\n",
        "    [[10,2,0],\n",
        "     [1,0,2]],\n",
        "\n",
        "    [[2,1,9],\n",
        "     [4,-3,32]]\n",
        "])\n",
        "print(tensor_three_d)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eYSJIa4Fp7Wl",
        "outputId": "7985a1ba-87b9-404a-aa97-880bbadf5ad0"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[[ 1  2  0]\n",
            "  [ 3  5 -1]]\n",
            "\n",
            " [[10  2  0]\n",
            "  [ 1  0  2]]\n",
            "\n",
            " [[ 2  1  9]\n",
            "  [ 4 -3 32]]], shape=(3, 2, 3), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A 4-dimensional tensor is an array of numerical values arranged in multiple 3D tensors, representing a collection of cubes, often used to represent a batch of images or a sequence of 3D data.\n",
        "\n",
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "yTaO1rCntEgD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_four_d = tf.constant([\n",
        "    [\n",
        "        [[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]]\n",
        "    ],\n",
        "\n",
        "    [\n",
        "        [[19,20,21],\n",
        "         [22,23,24]],\n",
        "\n",
        "        [[25,26,27],\n",
        "         [28,29,30]],\n",
        "\n",
        "        [[31,32,33],\n",
        "         [34,35,36]]\n",
        "    ]\n",
        "])\n",
        "\n",
        "print(tensor_four_d)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v-krZQy9tRRX",
        "outputId": "0ecbd1b2-d3e6-4f5d-da4f-cfb48cb75715"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[[[ 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]]]\n",
            "\n",
            "\n",
            " [[[19 20 21]\n",
            "   [22 23 24]]\n",
            "\n",
            "  [[25 26 27]\n",
            "   [28 29 30]]\n",
            "\n",
            "  [[31 32 33]\n",
            "   [34 35 36]]]], shape=(2, 3, 2, 3), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tensor.shape` is used to get the shape of a tensor, returning a tuple that represents the dimensions of the tensor.\n"
      ],
      "metadata": {
        "id": "bvep64HIrA3n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_zero_d.shape) # 0d\n",
        "\n",
        "print(tensor_one_d.shape) # 1d\n",
        "\n",
        "print(tensor_two_d.shape) # 2d\n",
        "\n",
        "print(tensor_three_d.shape) # 3d\n",
        "\n",
        "print(tensor_four_d.shape) # 4d"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ON6REcwfrB7V",
        "outputId": "22fbbded-b792-4523-95f0-9eae49dd81fe"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "()\n",
            "(3,)\n",
            "(4, 3)\n",
            "(3, 2, 3)\n",
            "(2, 3, 2, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tensor.cast()` is used to change the data type of a tensor to a specified type, such as casting a tensor from `tf.float32` to `tf.int32`."
      ],
      "metadata": {
        "id": "nP6Oj3sVwQE3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_one_d = tf.constant([2.1, 3.2, 4, 3.3], dtype=tf.float32)\n",
        "print(tensor_one_d)\n",
        "\n",
        "casted_tensor_one_d = tf.cast(tensor_one_d, dtype=tf.int32)\n",
        "print(casted_tensor_one_d)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rBMbxwmlwSlY",
        "outputId": "1d5f9d97-b50d-4474-8d32-6d5ba9138862"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([2.1 3.2 4.  3.3], shape=(4,), dtype=float32)\n",
            "tf.Tensor([2 3 4 3], shape=(4,), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "bOmdZKfmw7vN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In NumPy, `numpy.array()` is used to create an array from a list or a sequence of elements, converting the input into a NumPy array.\n"
      ],
      "metadata": {
        "id": "U3H5GUy4rX1y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np"
      ],
      "metadata": {
        "id": "TSreDtpWre36"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np_array = np.array([1,2,3])\n",
        "\n",
        "print(np_array)"
      ],
      "metadata": {
        "id": "LRbmpTQNrpaY",
        "outputId": "201c23e4-3700-4590-c3c0-a5c5a16f6f84",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tf.convert_to_tensor()` is used to convert a given input, such as a NumPy array or a Python list, into a TensorFlow tensor."
      ],
      "metadata": {
        "id": "1pEE4gTUsKnY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "converted_tensor = tf.convert_to_tensor(np_array)\n",
        "\n",
        "print(converted_tensor)"
      ],
      "metadata": {
        "id": "wBgqMfeGsOKB",
        "outputId": "c1e2b2fb-edf8-4e7d-f8b1-574fb63fc9e9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([1 2 3], shape=(3,), dtype=int64)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tf.eye()` is used to create a 2-dimensional identity matrix with ones on the diagonal and zeros elsewhere."
      ],
      "metadata": {
        "id": "Z2PTGVCMs914"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "eye_tensor = tf.eye(\n",
        "    num_rows=3,\n",
        "    num_columns=None,\n",
        "    batch_shape=None,\n",
        "    dtype=tf.dtypes.float32,\n",
        "    name=None\n",
        ")\n",
        "\n",
        "print(eye_tensor)"
      ],
      "metadata": {
        "id": "wzqGUG4ItA1J",
        "outputId": "8c11a41a-42e6-4706-aa89-88f4feeba260",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[1. 0. 0.]\n",
            " [0. 1. 0.]\n",
            " [0. 0. 1.]], shape=(3, 3), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "eye_tensor = tf.eye(\n",
        "    num_rows=3,\n",
        "    num_columns=None,\n",
        "    batch_shape=[2,],\n",
        "    dtype=tf.dtypes.float32,\n",
        "    name=None\n",
        ")\n",
        "\n",
        "print(eye_tensor)"
      ],
      "metadata": {
        "id": "sgE-J-ACudhX",
        "outputId": "41c2af29-2be6-4882-9c73-d446614f9a24",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[[1. 0. 0.]\n",
            "  [0. 1. 0.]\n",
            "  [0. 0. 1.]]\n",
            "\n",
            " [[1. 0. 0.]\n",
            "  [0. 1. 0.]\n",
            "  [0. 0. 1.]]], shape=(2, 3, 3), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "eye_tensor = tf.eye(\n",
        "    num_rows=3,\n",
        "    num_columns=None,\n",
        "    batch_shape=[2,2],\n",
        "    dtype=tf.dtypes.float32,\n",
        "    name=None\n",
        ")\n",
        "\n",
        "print(eye_tensor)"
      ],
      "metadata": {
        "id": "CMpbAjEHu2AP",
        "outputId": "bbc908c3-e956-4513-babf-ab21d66f961a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[[[1. 0. 0.]\n",
            "   [0. 1. 0.]\n",
            "   [0. 0. 1.]]\n",
            "\n",
            "  [[1. 0. 0.]\n",
            "   [0. 1. 0.]\n",
            "   [0. 0. 1.]]]\n",
            "\n",
            "\n",
            " [[[1. 0. 0.]\n",
            "   [0. 1. 0.]\n",
            "   [0. 0. 1.]]\n",
            "\n",
            "  [[1. 0. 0.]\n",
            "   [0. 1. 0.]\n",
            "   [0. 0. 1.]]]], shape=(2, 2, 3, 3), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tf.fill()` is used to create a tensor with a specified shape and filled with a scalar value. The function signature is `tf.fill(dims, value)`, where `dims` is the shape of the tensor and `value` is the scalar value to fill the tensor with."
      ],
      "metadata": {
        "id": "rIkoykS0vQ8I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "filled_tensor = tf.fill([3,4], 5)\n",
        "\n",
        "print(filled_tensor)"
      ],
      "metadata": {
        "id": "-ZZ_m4nJvPTa",
        "outputId": "468bdfb0-3375-49b0-8783-30eed5e1c26b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[5 5 5 5]\n",
            " [5 5 5 5]\n",
            " [5 5 5 5]], shape=(3, 4), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tf.ones()` is used to create a tensor with a specified shape and filled with ones."
      ],
      "metadata": {
        "id": "K0Dol2iKv-Tu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ones_tensor = tf.ones([3,4])\n",
        "\n",
        "print(ones_tensor)"
      ],
      "metadata": {
        "id": "mPMEQOLQwCHp",
        "outputId": "7aeaa67b-f1d1-4234-a4b8-24c63854ea52",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[1. 1. 1. 1.]\n",
            " [1. 1. 1. 1.]\n",
            " [1. 1. 1. 1.]], shape=(3, 4), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tf.ones_like()` is used to create a tensor of ones with the same shape and data type as a given input tensor. The function signature is `tf.ones_like(input_tensor, dtype=None, name=None)`, where `input_tensor` is the tensor whose shape and data type are to be matched, and `dtype` (optional) specifies the data type of the new tensor."
      ],
      "metadata": {
        "id": "d7-GPLoQwql8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ones_like_tensor = tf.ones_like(filled_tensor)\n",
        "\n",
        "print(ones_like_tensor)"
      ],
      "metadata": {
        "id": "kOMt01WJwv5K",
        "outputId": "e1f14dfe-71ae-4028-f27f-9bb47e88799c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[1 1 1 1]\n",
            " [1 1 1 1]\n",
            " [1 1 1 1]], shape=(3, 4), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tf.zeros()` is used to create a tensor with a specified shape and filled with zeros. The function signature is `tf.zeros(shape, dtype=tf.float32, name=None)`"
      ],
      "metadata": {
        "id": "_irhs64Px0X7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "zeros_tensor = tf.zeros([3,4])\n",
        "\n",
        "print(zeros_tensor)"
      ],
      "metadata": {
        "id": "mKeRUaJ9x3x4",
        "outputId": "6a4f428f-60fa-4009-8afd-d27f59abd5f7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[0. 0. 0. 0.]\n",
            " [0. 0. 0. 0.]\n",
            " [0. 0. 0. 0.]], shape=(3, 4), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tf.zeros_like()` is used to create a tensor of zeros with the same shape and data type as a given input tensor. The function signature is `tf.zeros_like(input_tensor, dtype=None, name=None, optimize=True)`"
      ],
      "metadata": {
        "id": "42y1t0YayO7M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "zeros_like_tensor = tf.zeros_like(filled_tensor)\n",
        "\n",
        "print(zeros_like_tensor)"
      ],
      "metadata": {
        "id": "50xcawveyV_7",
        "outputId": "103dbae6-e140-49ce-e900-3866b523684f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[0 0 0 0]\n",
            " [0 0 0 0]\n",
            " [0 0 0 0]], shape=(3, 4), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tf.shape()` is used to get the shape of a tensor as a 1-D tensor of type int32. The function signature is `tf.shape(input, out_type=tf.dtypes.int32, name=None)`, where `input` is the tensor whose shape is to be determined, `out_type (optional)` specifies the output data type (default is int32), and `name` (optional) gives a name to the operation."
      ],
      "metadata": {
        "id": "vNfCQyBlymeJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_three_d_shape = tf.shape(tensor_three_d)\n",
        "\n",
        "print(tensor_three_d_shape)"
      ],
      "metadata": {
        "id": "Hx0GVz7AzOFZ",
        "outputId": "de96ebd2-0fdc-4ed4-e6f0-3f448eb558e1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([3 2 3], shape=(3,), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tf.rank()` returns the number of dimensions of a tensor."
      ],
      "metadata": {
        "id": "_WTxvp4v0N21"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = tf.constant([[[1,1,1], [2,2,2]], [[3,3,3], [4,4,4]]])\n",
        "\n",
        "print(tf.rank(tensor))"
      ],
      "metadata": {
        "id": "Z7ClWxCC0Qgc",
        "outputId": "faeb7c91-500e-4a02-bdc1-3003380136ce",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(3, shape=(), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tf.size()` returns the total number of elements in a tensor. The function signature is `tf.size(input, out_type=tf.dtypes.int32, name=None)`"
      ],
      "metadata": {
        "id": "l6OINgCY1Pzs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tf.size(tensor))"
      ],
      "metadata": {
        "id": "IOFgoYK01Tsr",
        "outputId": "31b48a83-6d3a-455c-dd67-13efafae429b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(12, shape=(), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tf.random.normal()` generates a tensor of random values drawn from a normal distribution. The function signature is `tf.random.normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)`"
      ],
      "metadata": {
        "id": "BUMFkdNs2AsB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "random_tensor = tf.random.normal(shape=[2,3,2])\n",
        "\n",
        "print(random_tensor)"
      ],
      "metadata": {
        "id": "r0Ub7Yyh2Edf",
        "outputId": "a4e1502a-da3e-462c-dd4d-0e6db878b775",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[[ 0.5288095   0.19359903]\n",
            "  [ 0.8542151  -0.1568846 ]\n",
            "  [ 0.0033131   1.5257927 ]]\n",
            "\n",
            " [[-0.47749874  0.38242435]\n",
            "  [ 0.8648876   1.455506  ]\n",
            "  [ 0.15787138 -0.0037236 ]]], shape=(2, 3, 2), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tf.random.uniform()` generates a tensor of random values drawn from a uniform distribution. The function signature is `tf.random.uniform(shape, minval=0, maxval=None, dtype=tf.float32, seed=None, name=None)` where:\n",
        "\n",
        "`shape` specifies the shape of the output tensor.\n",
        "\n",
        "`minval` is the lower bound of the uniform distribution (default is 0).\n",
        "\n",
        "`maxval` is the upper bound of the distribution (if None, defaults to 1)."
      ],
      "metadata": {
        "id": "P1ht1Uc845BW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "random_uniform_tensor = tf.random.uniform(shape=[2,3,2])\n",
        "\n",
        "print(random_uniform_tensor)"
      ],
      "metadata": {
        "id": "adZ6W2F144s4",
        "outputId": "fc50d2cf-c189-4581-d137-1c24d56c8281",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[[0.8624009  0.13641047]\n",
            "  [0.01917815 0.33933938]\n",
            "  [0.36999547 0.21268702]]\n",
            "\n",
            " [[0.6712866  0.91566265]\n",
            "  [0.29582715 0.8164396 ]\n",
            "  [0.00506139 0.6956626 ]]], shape=(2, 3, 2), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Indexing"
      ],
      "metadata": {
        "id": "tkCoY3ez7i_y"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tensor indexing is the process of accessing specific elements, slices, or sub-tensors within a multi-dimensional tensor using indices along each dimension."
      ],
      "metadata": {
        "id": "aWW0hIRP2NQs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = tf.constant([3,6,2,4,66,7])\n",
        "\n",
        "print(tensor)\n",
        "print(tensor[0:4])\n",
        "print(tensor[:4])\n",
        "print(tensor[3:])\n",
        "print(tensor[1:-1]) # Accesses the elements starting from index 1 to the second-to-last element\n",
        "print(tensor[0:6:2]) # Accesses every second element starting from index 0 up to index 5"
      ],
      "metadata": {
        "id": "XgYKEuDi2Opm",
        "outputId": "08a4a00f-b5d2-44f4-cba8-c6d271418e2f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([ 3  6  2  4 66  7], shape=(6,), dtype=int32)\n",
            "tf.Tensor([3 6 2 4], shape=(4,), dtype=int32)\n",
            "tf.Tensor([3 6 2 4], shape=(4,), dtype=int32)\n",
            "tf.Tensor([ 4 66  7], shape=(3,), dtype=int32)\n",
            "tf.Tensor([ 6  2  4 66], shape=(4,), dtype=int32)\n",
            "tf.Tensor([ 3  2 66], shape=(3,), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_two_d, \"\\n\")\n",
        "\n",
        "print(tensor_two_d[:3 , :2], \"\\n\") # This selects the first 3 rows (0, 1, 2) and the first 2 columns (0, 1) of the 2D tensor.\n",
        "\n",
        "print(tensor_two_d[:3,:], \"\\n\") # This selects the first 3 rows (0, 1, 2) and all columns of the 2D tensor.\n",
        "\n",
        "print(tensor_two_d[2,:], \"\\n\")"
      ],
      "metadata": {
        "id": "81Z3FyKO32l0",
        "outputId": "e337574b-fdcc-482a-c71d-5546a54d5ebe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]\n",
            " [ 1  5  6]\n",
            " [ 2  3  8]], shape=(4, 3), dtype=int32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[1 2]\n",
            " [3 5]\n",
            " [1 5]], shape=(3, 2), dtype=int32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]\n",
            " [ 1  5  6]], shape=(3, 3), dtype=int32) \n",
            "\n",
            "tf.Tensor([1 5 6], shape=(3,), dtype=int32) \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_three_d, \"\\n\")\n",
        "\n",
        "print(tensor_three_d[0, :, :], \"\\n\") # selecting first slice (index 0) of the 3D tensor, which includes all elements across the second and third dimensions\n",
        "\n",
        "print(tensor_three_d[:1, :2, 0], \"\\n\") #  selecting the first slice, the first two elements of the second dimension, and the first element of the third dimension.\n",
        "\n",
        "print(tensor_three_d[..., :1, -1]) # all leading dimensions are included, but only the first element of the second-to-last dimension and the last element of the last dimension are selected\n"
      ],
      "metadata": {
        "id": "pcUIL51E5PuA",
        "outputId": "20009fac-3c19-4842-a5e3-9d1b278d8b39",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[[ 1  2  0]\n",
            "  [ 3  5 -1]]\n",
            "\n",
            " [[10  2  0]\n",
            "  [ 1  0  2]]\n",
            "\n",
            " [[ 2  1  9]\n",
            "  [ 4 -3 32]]], shape=(3, 2, 3), dtype=int32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]], shape=(2, 3), dtype=int32) \n",
            "\n",
            "tf.Tensor([[1 3]], shape=(1, 2), dtype=int32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[0]\n",
            " [0]\n",
            " [9]], shape=(3, 1), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Math Operations"
      ],
      "metadata": {
        "id": "aFytMNIF7bVz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "`tf.abs()` in TensorFlow computes the element-wise absolute value of the given tensor."
      ],
      "metadata": {
        "id": "GjO56rdW7ePU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = tf.constant([-2.25, 3.25, -4])\n",
        "\n",
        "tensor_abs = tf.abs(tensor)\n",
        "print(tensor_abs)"
      ],
      "metadata": {
        "id": "TkfdXzXQ8A2k",
        "outputId": "54a9e52e-0c82-4e7f-c07f-0261fabce47e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([2.25 3.25 4.  ], shape=(3,), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.sqrt(x)` function in TensorFlow computes the element-wise square root of the input tensor `x`."
      ],
      "metadata": {
        "id": "dm6D6E8L-vYU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_sqrt = tf.sqrt(tensor_abs)\n",
        "print(tensor_sqrt)"
      ],
      "metadata": {
        "id": "D7qwdYA08giN",
        "outputId": "2d5b2d9a-83e8-4f81-85aa-cf88c555211e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([1.5       1.8027756 2.       ], shape=(3,), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.add(x, y)` function in TensorFlow performs element-wise addition of two tensors `x` and `y`. The tensors must have the same shape, or be broadcastable to a common shape."
      ],
      "metadata": {
        "id": "-9J8wfhc_NCE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.add(tensor_abs, tensor_sqrt)"
      ],
      "metadata": {
        "id": "8Y2bQwIM_RsF",
        "outputId": "2858fa95-56c8-45ed-c321-09a5d3fb9a7c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=float32, numpy=array([3.75     , 5.0527754, 6.       ], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.multiply(x, y)` function in TensorFlow performs element-wise multiplication of two tensors `x` and `y`. The tensors must have the same shape or be broadcastable to a common shape."
      ],
      "metadata": {
        "id": "ZD1i7s72_iQ6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.multiply(tensor_abs, tensor_sqrt)"
      ],
      "metadata": {
        "id": "CS98pDcS_l95",
        "outputId": "a02f4a10-3b54-4d94-b943-b1628c344621",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=float32, numpy=array([3.375    , 5.8590207, 8.       ], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.divide(x, y)` function in TensorFlow performs element-wise division of tensor `x` by tensor `y`. The tensors must have the same shape or be broadcastable to a common shape."
      ],
      "metadata": {
        "id": "V8HXvFss_5DT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.divide(tensor_abs, tensor_sqrt)"
      ],
      "metadata": {
        "id": "sEYhDN6C_8DE",
        "outputId": "0b1f0f70-946c-4390-d311-3b354ec79699",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=float32, numpy=array([1.5      , 1.8027756, 2.       ], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.math.divide_no_nan(x, y)` function in TensorFlow performs element-wise division of tensor `x` by tensor `y`, but handles cases where the denominator (`y`) is `zero` or `NaN` (Not a Number). Instead of producing NaNs or infinities in such cases, it returns a specified default value for these situations. This helps to avoid undefined or erroneous results in computations."
      ],
      "metadata": {
        "id": "odT7XEc8D6zd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.math.divide_no_nan(tensor_abs, 0)"
      ],
      "metadata": {
        "id": "F2xqwQZ2EDLl",
        "outputId": "aa8eb2f1-a6ff-4d0d-d7cf-3d3633043c14",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.math.maximum(x, y)` function in TensorFlow performs element-wise comparison between two tensors `x` and `y`, returning a new tensor where each element is the maximum of the corresponding elements in `x` and `y`. The tensors must have the same shape or be broadcastable to a common shape."
      ],
      "metadata": {
        "id": "i2vLBvndF2LA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_abs, \"\\n\\n\", tensor_sqrt, \"\\n\")\n",
        "\n",
        "tf.maximum(tensor_abs, tensor_sqrt)"
      ],
      "metadata": {
        "id": "EJAdt2JtGA9z",
        "outputId": "4aa16a6a-f9da-466f-b77a-39744082c09a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([2.25 3.25 4.  ], shape=(3,), dtype=float32) \n",
            "\n",
            " tf.Tensor([1.5       1.8027756 2.       ], shape=(3,), dtype=float32) \n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=float32, numpy=array([2.25, 3.25, 4.  ], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.math.minimum(x, y)` function in TensorFlow performs element-wise comparison between two tensors `x` and `y`, returning a new tensor where each element is the minimum of the corresponding elements in `x` and `y`. The tensors must have the same shape or be broadcastable to a common shape."
      ],
      "metadata": {
        "id": "YWMVykpQGtjV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.minimum(tensor_abs, tensor_sqrt)"
      ],
      "metadata": {
        "id": "mPBvVskPG6TH",
        "outputId": "d53efc5f-7d4c-4701-86dc-5b091c31af89",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=float32, numpy=array([1.5      , 1.8027756, 2.       ], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.math.argmax(x, axis)` function in TensorFlow returns the **indices** of the maximum values along a specified axis of the tensor `x`. The `axis` parameter specifies the dimension along which to find the maximum values. The result is a tensor of indices where each element represents the index of the maximum value in that dimension. If `axis` is not specified, it defaults to finding the index of the maximum value across the entire tensor."
      ],
      "metadata": {
        "id": "bCsPhgztHQzp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor, \"\\n\")\n",
        "\n",
        "print(tf.math.argmax(tensor)) # Return index 1"
      ],
      "metadata": {
        "id": "vEVDPKltHgvy",
        "outputId": "43bc8719-c308-4802-9781-cd6399219bf8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([-2.25  3.25 -4.  ], shape=(3,), dtype=float32) \n",
            "\n",
            "tf.Tensor(1, shape=(), dtype=int64)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_three_d, \"\\n\") # Has three dimensions => 0 for layers axis, 1 for rows axis, 2 for columns axis\n",
        "\n",
        "print(tf.math.argmax(tensor_three_d, 1))"
      ],
      "metadata": {
        "id": "SUfoSYWHIUpd",
        "outputId": "93f7af0c-b4b7-4b86-b3fb-cdbbcb3a827c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[[ 1  2  0]\n",
            "  [ 3  5 -1]]\n",
            "\n",
            " [[10  2  0]\n",
            "  [ 1  0  2]]\n",
            "\n",
            " [[ 2  1  9]\n",
            "  [ 4 -3 32]]], shape=(3, 2, 3), dtype=int32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[1 1 0]\n",
            " [0 0 1]\n",
            " [1 0 1]], shape=(3, 3), dtype=int64)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.math.argmin(x, axis)` function in TensorFlow returns the indices of the **minimum** values along a specified axis of the tensor `x`. The `axis` parameter indicates the dimension along which to find the minimum values. The result is a tensor of indices where each element represents the index of the minimum value in that dimension. If `axis` is not specified, it defaults to finding the index of the minimum value across the entire tensor."
      ],
      "metadata": {
        "id": "HGWOWyfLKZ8O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tf.math.argmin(tensor_three_d, 1))"
      ],
      "metadata": {
        "id": "NNX5WIlrKl65",
        "outputId": "d86976a2-fac9-4e08-fb00-57057296149a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[0 0 1]\n",
            " [1 1 0]\n",
            " [0 1 0]], shape=(3, 3), dtype=int64)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.math.equal(x, y)` function in TensorFlow performs element-wise comparison between two tensors `x` and `y`, returning a tensor of boolean values where each element is `True` if the corresponding elements in `x` and `y` are equal, and `False` otherwise. The tensors must have the same shape or be broadcastable to a common shape."
      ],
      "metadata": {
        "id": "mpiU8JENK2Hb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.math.equal(tensor_abs, tensor_sqrt)"
      ],
      "metadata": {
        "id": "OGyzV10DK9l2",
        "outputId": "a9a1f8dd-1236-40a9-a9cd-7969cd675400",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=bool, numpy=array([False, False, False])>"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.math.pow(x, y)` function in TensorFlow performs element-wise exponentiation, where each element of tensor `x` is raised to the power of the corresponding element in tensor `y`. The tensors `x` and `y` must have the same shape or be broadcastable to a common shape.\n"
      ],
      "metadata": {
        "id": "Xe7IJZvqLXaC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tf.math.pow(tensor_abs, 2))\n",
        "\n",
        "print(tf.math.pow(tensor_abs, [2, 3, 4]))"
      ],
      "metadata": {
        "id": "8FZZFEF1LdDI",
        "outputId": "e8247d02-813b-4802-dc6c-ddcb517dbf36",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([ 5.0625 10.5625 16.    ], shape=(3,), dtype=float32)\n",
            "tf.Tensor([  5.0625    34.328125 256.      ], shape=(3,), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.reduce_sum(input_tensor, axis)` function in TensorFlow computes the sum of elements across a specified `axis` of the tensor `input_tensor`. If `axis` is not specified, it sums all elements of the tensor. The result is a tensor with reduced dimensions based on the specified axis, where each element is the sum of the elements along that axis."
      ],
      "metadata": {
        "id": "sT-Ujh6XMYsa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_two_d, \"\\n\")\n",
        "\n",
        "print(tf.reduce_sum(tensor_two_d), \"\\n\") # Returns the sums of all values\n",
        "\n",
        "print(tf.reduce_sum(tensor_two_d, 0), \"\\n\") # Returns the sums of all row values in each column\n",
        "\n",
        "print(tf.reduce_sum(tensor_two_d, 1)) # Returns the sums of all column values in each row\n",
        "\n"
      ],
      "metadata": {
        "id": "pr6PXzcNMg1n",
        "outputId": "9be671a5-dd93-4e1d-e02d-1e174c4db440",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]\n",
            " [ 1  5  6]\n",
            " [ 2  3  8]], shape=(4, 3), dtype=int32) \n",
            "\n",
            "tf.Tensor(35, shape=(), dtype=int32) \n",
            "\n",
            "tf.Tensor([ 7 15 13], shape=(3,), dtype=int32) \n",
            "\n",
            "tf.Tensor([ 3  7 12 13], shape=(4,), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "TensorFlow provides several `tf.reduce_*` functions to perform reduction operations on tensors. Some of the commonly used ones include:\n",
        "\n",
        "`tf.reduce_mean(input_tensor, axis)`: Computes the mean of elements across the specified axis.\n",
        "\n",
        "`tf.reduce_max(input_tensor, axis)`: Finds the maximum value of elements across the specified axis.\n",
        "\n",
        "`tf.reduce_min(input_tensor, axis)`: Finds the minimum value of elements across the specified axis.\n",
        "\n",
        "`tf.reduce_prod(input_tensor, axis)`: Computes the product of elements across the specified axis.\n",
        "\n",
        "`tf.reduce_all(input_tensor, axis)`: Returns True if all elements across the specified axis are True.\n",
        "\n",
        "`tf.reduce_any(input_tensor, axis)`: Returns True if any element across the specified axis is True.\n",
        "\n",
        "`tf.reduce_variance(input_tensor, axis)`: Computes the variance of elements across the specified axis.\n",
        "\n",
        "`tf.reduce_std(input_tensor, axis)`: Computes the standard deviation of elements across the specified axis."
      ],
      "metadata": {
        "id": "oRDff5gGNsJo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.math.sigmoid(x)` function in TensorFlow applies the sigmoid activation function element-wise to the input tensor `x`. The sigmoid function is defined as:\n",
        "\n",
        "`𝜎(𝑥) = 1 / (1 + 𝑒 ^ −𝑥)`\n",
        "\n",
        "This function maps input values to a range between 0 and 1, making it commonly used in binary classification problems and as an activation function in neural networks. The output tensor has the same shape as the input tensor, with each element transformed by the sigmoid function."
      ],
      "metadata": {
        "id": "95bA3tu3sIib"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_two_d, \"\\n\")\n",
        "tensor_two_d = np.array(tensor_two_d, dtype=np.float32)\n",
        "print(tf.math.sigmoid(tensor_two_d))"
      ],
      "metadata": {
        "id": "t76VD3uFs9dx",
        "outputId": "184e122a-59a0-4d95-c9b2-53cecf72b071",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]\n",
            " [ 1  5  6]\n",
            " [ 2  3  8]], shape=(4, 3), dtype=int32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[0.73105854 0.880797   0.5       ]\n",
            " [0.95257413 0.9933072  0.26894143]\n",
            " [0.73105854 0.9933072  0.9975274 ]\n",
            " [0.880797   0.95257413 0.99966466]], shape=(4, 3), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.math.top_k(input, k)` function in TensorFlow retrieves the top `k` highest values and their corresponding indices along the last dimension of the input tensor. The function returns a tuple containing two tensors:\n",
        "\n",
        "1. Values: A tensor of the top `k` values.\n",
        "2. Indices: A tensor of the indices corresponding to these top `k` values in the original tensor.\n",
        "\n",
        "The input tensor can be multi-dimensional, but the operation is applied along the last dimension by default. The result retains the shape of the input tensor, with the size of the last dimension reduced to `k`."
      ],
      "metadata": {
        "id": "2OtZrdurwnFk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_two_d, \"\\n\")\n",
        "tf.math.top_k(tensor_two_d)"
      ],
      "metadata": {
        "id": "aup9kBu9xOPB",
        "outputId": "3745c509-ef77-4773-a2f1-a6e8692f966c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1.  2.  0.]\n",
            " [ 3.  5. -1.]\n",
            " [ 1.  5.  6.]\n",
            " [ 2.  3.  8.]] \n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "TopKV2(values=<tf.Tensor: shape=(4, 1), dtype=float32, numpy=\n",
              "array([[2.],\n",
              "       [5.],\n",
              "       [6.],\n",
              "       [8.]], dtype=float32)>, indices=<tf.Tensor: shape=(4, 1), dtype=int32, numpy=\n",
              "array([[1],\n",
              "       [1],\n",
              "       [2],\n",
              "       [2]], dtype=int32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.math.top_k(tensor_two_d, k = 2)"
      ],
      "metadata": {
        "id": "nyEkD1u9yA6V",
        "outputId": "7656ff89-e487-4e9a-8af9-89121dfa9379",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "TopKV2(values=<tf.Tensor: shape=(4, 2), dtype=float32, numpy=\n",
              "array([[2., 1.],\n",
              "       [5., 3.],\n",
              "       [6., 5.],\n",
              "       [8., 3.]], dtype=float32)>, indices=<tf.Tensor: shape=(4, 2), dtype=int32, numpy=\n",
              "array([[1, 0],\n",
              "       [1, 0],\n",
              "       [2, 1],\n",
              "       [2, 1]], dtype=int32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Linear Algebra"
      ],
      "metadata": {
        "id": "i0FVFrUNyZjv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.linalg.matmul(a, b)` function in TensorFlow performs **matrix multiplication** between two tensors `a` and `b`. For 2D tensors, it computes the dot product of rows from `a` with columns from `b`.\n",
        "\n",
        "For higher-dimensional tensors, it applies matrix multiplication to the last two dimensions while broadcasting across the other dimensions as needed. The shapes of `a` and `b` must be compatible for this operation."
      ],
      "metadata": {
        "id": "U_tHDYy7ycK7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mat_1 = tf.constant([[1,2,0],\n",
        "                     [3,5,-1]])\n",
        "\n",
        "mat_2 = tf.constant([[1,2,0],\n",
        "                     [3,5,-1],\n",
        "                     [4,5,6]])\n",
        "\n",
        "print(mat_1.shape, mat_2.shape, \"\\n\")\n",
        "\n",
        "tf.linalg.matmul(mat_1, mat_2) # Number of columns in mat_1 should be = Number of rows in mat_2\n",
        "                              # Output shape is based on mat_1 rows and mat_2 columns"
      ],
      "metadata": {
        "id": "1pJ6dMX9zIRL",
        "outputId": "ba39665a-a690-4eea-d412-9a5180fae20b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(2, 3) (3, 3) \n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3), dtype=int32, numpy=\n",
              "array([[  7,  12,  -2],\n",
              "       [ 14,  26, -11]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "An alternative way to perfom matrix multiplication is to use `@`."
      ],
      "metadata": {
        "id": "1sYvwv3f1J-s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(mat_1 @ mat_2)"
      ],
      "metadata": {
        "id": "Mr2qhdWK1S50",
        "outputId": "ad891321-4525-449a-a348-aea219a05707",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[  7  12  -2]\n",
            " [ 14  26 -11]], shape=(2, 3), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.transpose(x, perm)` function in TensorFlow swaps the dimensions of the tensor `x` according to the specified permutation `perm`. The `perm` parameter is a list or tuple that defines the desired ordering of the dimensions. If `perm` is not specified, it reverses the order of the dimensions by default."
      ],
      "metadata": {
        "id": "RtYMkn-DxwsB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.transpose(mat_1)"
      ],
      "metadata": {
        "id": "7MZiXyO1x2r8",
        "outputId": "729de5dc-d108-4250-c0f2-761d9a23eed1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              "array([[ 1,  3],\n",
              "       [ 2,  5],\n",
              "       [ 0, -1]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.linalg.band_part(input, num_lower, num_upper)` function extracts a band from a matrix, keeping the main diagonal and a specified number of diagonals above (`num_upper`) and below (`num_lower`), while setting all other elements to zero.\n",
        "\n",
        "* `num_lower`: The number of sub-diagonals to include below\n",
        "the main diagonal. If set to a non-negative integer, it includes that many diagonals below the main diagonal. If set to -1, all sub-diagonals are included.\n",
        "\n",
        "* `num_upper`: The number of super-diagonals to include above the main diagonal. If set to a non-negative integer, it includes that many diagonals above the main diagonal. If set to -1, all super-diagonals are included.\n",
        "\n"
      ],
      "metadata": {
        "id": "w8I1MlMB7VmZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_two_d, \"\\n\")\n",
        "\n",
        "print(tf.linalg.band_part(tensor_two_d, 0, 0), \"\\n\") # Extracts only the main diagonal of the 2D tensor, setting all other elements to zero\n",
        "\n",
        "print(tf.linalg.band_part(tensor_two_d, 1, 1)) # Extracts a band around the main diagonal of the 2D tensor, including the main diagonal, one sub-diagonal (below the main diagonal), and one super-diagonal (above the main diagonal). All other elements outside this band are set to zero.\n"
      ],
      "metadata": {
        "id": "e386NU6389cb",
        "outputId": "7f950953-7b5d-4d58-9664-d520444747e6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1.  2.  0.]\n",
            " [ 3.  5. -1.]\n",
            " [ 1.  5.  6.]\n",
            " [ 2.  3.  8.]] \n",
            "\n",
            "tf.Tensor(\n",
            "[[1. 0. 0.]\n",
            " [0. 5. 0.]\n",
            " [0. 0. 6.]\n",
            " [0. 0. 0.]], shape=(4, 3), dtype=float32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[ 1.  2.  0.]\n",
            " [ 3.  5. -1.]\n",
            " [ 0.  5.  6.]\n",
            " [ 0.  0.  8.]], shape=(4, 3), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.linalg.cross(a, b)` function computes the 3D cross product of two tensors `a` and `b` along their last dimension, resulting in a tensor of vectors perpendicular to the input vectors.\n",
        "\n",
        "* `a` and `b`: Must be tensors with shape `(..., 3)`, where the last dimension has size 3.\n",
        "\n",
        "The result is a tensor with the same shape as `a` and `b`, containing the cross product for each pair of corresponding 3D vectors in the input tensors.\n"
      ],
      "metadata": {
        "id": "knjVQVOp_Y_s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(mat_1, \"\\n\")\n",
        "\n",
        "print(tf.linalg.cross(mat_1, mat_1))"
      ],
      "metadata": {
        "id": "4Iskt_nL_5az",
        "outputId": "3a199bad-38f6-4169-e0e8-89004ec6230b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]], shape=(2, 3), dtype=int32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[0 0 0]\n",
            " [0 0 0]], shape=(2, 3), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.linalg.inv(x)` function in TensorFlow computes the inverse of a square matrix or a batch of square matrices. The input tensor `x` must be a square matrix (2D) or a batch of square matrices (3D), and the result is a tensor of the same shape where each matrix is replaced by its inverse."
      ],
      "metadata": {
        "id": "tO-o03KpAp7i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mat_3 = tf.constant([[1,2,0],\n",
        "                     [4,-5,60],\n",
        "                     [7,18,-9]], dtype=tf.float32)\n",
        "\n",
        "tf.linalg.inv(mat_3)"
      ],
      "metadata": {
        "id": "q86PsCBdAwiL",
        "outputId": "be4e0b3d-ae1e-41c3-f6cc-74a003b511c0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=float32, numpy=\n",
              "array([[ 8.414635  , -0.14634147, -0.9756098 ],\n",
              "       [-3.7073174 ,  0.07317074,  0.4878049 ],\n",
              "       [-0.86991876,  0.03252033,  0.10569107]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.linalg.svd(x)` function in TensorFlow computes the Singular Value Decomposition (SVD) of a matrix or a batch of matrices. It decomposes the input tensor `x` into three components:\n",
        "\n",
        "1. `U`: A tensor of left singular vectors.\n",
        "\n",
        "2. `S`: A tensor of singular values (diagonal matrix or vector).\n",
        "\n",
        "3. `V`: A tensor of right singular vectors (transposed if `x` is a matrix).\n",
        "\n",
        "For a matrix `x`, the decomposition is `𝑥 = 𝑈 ⋅ 𝑆 ⋅ 𝑉 ^ T`\n",
        "\n",
        "If `x` is a batch of matrices, the function returns the decomposition for each matrix in the batch."
      ],
      "metadata": {
        "id": "8RSAELvhCC3A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(mat_3, \"\\n\")\n",
        "\n",
        "s,u,v = tf.linalg.svd(mat_3)\n",
        "\n",
        "print(s, \"\\n\")\n",
        "print(u, \"\\n\")\n",
        "print(v)"
      ],
      "metadata": {
        "id": "HBTioaLfCm8-",
        "outputId": "7be99699-a12a-4674-b3c7-d95be41bffce",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ 1.  2.  0.]\n",
            " [ 4. -5. 60.]\n",
            " [ 7. 18. -9.]], shape=(3, 3), dtype=float32) \n",
            "\n",
            "tf.Tensor([61.245174   18.681993    0.10750052], shape=(3,), dtype=float32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[ 0.00363813  0.11895824 -0.9928925 ]\n",
            " [-0.98372084  0.17881788  0.01781972]\n",
            " [ 0.1796668   0.9766641   0.11767227]], shape=(3, 3), dtype=float32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[-0.04365371  0.41060278 -0.91076875]\n",
            " [ 0.13323301  0.9058872   0.40201622]\n",
            " [-0.9901228   0.10379489  0.09425117]], shape=(3, 3), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.einsum(equation, *inputs)` function performs tensor operations using Einstein summation notation, allowing for complex reductions and multiplications specified in a concise string format.\n",
        "\n",
        "* `equation`: A string that defines the desired tensor operation, including summation and contraction patterns.\n",
        "\n",
        "* `*inputs`: The tensors to be operated on, matching the dimensions specified in the equation.\n",
        "\n",
        "For example, `tf.einsum('ij,jk->ik', A, B)` performs **matrix multiplication** of tensors `A` and `B`, where `'ij'` and `'jk'` represent the indices of `A` and `B` respectively, and `'ik'` represents the resulting tensor's indices."
      ],
      "metadata": {
        "id": "4h0aSEibD3PM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(mat_1, \"\\n\\n\", mat_2, \"\\n\\n\")\n",
        "\n",
        "tf.einsum(\"ij,jk->ik\", mat_1, mat_2)"
      ],
      "metadata": {
        "id": "_X6WwDhGEdL9",
        "outputId": "3a39ff98-ba02-4c94-f048-f183c2536abd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]], shape=(2, 3), dtype=int32) \n",
            "\n",
            " tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]\n",
            " [ 4  5  6]], shape=(3, 3), dtype=int32) \n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3), dtype=int32, numpy=\n",
              "array([[  7,  12,  -2],\n",
              "       [ 14,  26, -11]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "mat_4 = tf.constant([[1,1,2],\n",
        "                     [4,-2,-1]])\n",
        "\n",
        "print(mat_1, \"\\n\\n\", mat_4, \"\\n\\n\")\n",
        "\n",
        "tf.einsum(\"ij,ij->ij\", mat_1, mat_4) # Matrix multiplication (Element-wise)"
      ],
      "metadata": {
        "id": "IOWxgxOOGFxd",
        "outputId": "590813fd-b636-49b0-fa78-98db72772f19",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]], shape=(2, 3), dtype=int32) \n",
            "\n",
            " tf.Tensor(\n",
            "[[ 1  1  2]\n",
            " [ 4 -2 -1]], shape=(2, 3), dtype=int32) \n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3), dtype=int32, numpy=\n",
              "array([[  1,   2,   0],\n",
              "       [ 12, -10,   1]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(mat_1, \"\\n\\n\")\n",
        "\n",
        "tf.einsum(\"ij -> ji\", mat_1) # Transpose matrix"
      ],
      "metadata": {
        "id": "HC1wWU3GG-kG",
        "outputId": "4c708021-368a-47b2-c9f0-183e4fb13795",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]], shape=(2, 3), dtype=int32) \n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              "array([[ 1,  3],\n",
              "       [ 2,  5],\n",
              "       [ 0, -1]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "batch_1 = tf.constant([\n",
        "    [[2,6,5,2],\n",
        "     [2,-2,2,3],\n",
        "     [1,5,4,0]],\n",
        "\n",
        "    [[1,3,1,22],\n",
        "     [0,2,2,0],\n",
        "     [1,5,4,1]]\n",
        "    ])\n",
        "\n",
        "batch_2 = tf.constant([\n",
        "    [[2,9,0,3,0],\n",
        "     [3,6,8,-2,2],\n",
        "     [1,3,5,0,1],\n",
        "     [3,0,2,0,5]],\n",
        "\n",
        "    [[1,0,0,3,0],\n",
        "     [3,0,4,-2,2],\n",
        "     [1,0,2,0,0],\n",
        "     [3,0,1,1,0]]\n",
        "])\n",
        "\n",
        "tf.einsum(\"bij, bjk -> bik\", batch_1, batch_2) # Batch Multiplication"
      ],
      "metadata": {
        "id": "U5gwHMRTIFVg",
        "outputId": "726cedb8-7ee3-48c2-b08d-2f38d2d2d7dd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3, 5), dtype=int32, numpy=\n",
              "array([[[33, 69, 77, -6, 27],\n",
              "        [ 9, 12,  0, 10, 13],\n",
              "        [21, 51, 60, -7, 14]],\n",
              "\n",
              "       [[77,  0, 36, 19,  6],\n",
              "        [ 8,  0, 12, -4,  4],\n",
              "        [23,  0, 29, -6, 10]]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(tf.einsum(\"bij -> \", batch_1), \"\\n\\n\") # Sum of all elements in a batch\n",
        "\n",
        "print(tf.einsum(\"bij -> j\", batch_1), \"\\n\\n\") # Sum of all  elements in a batch column-wise\n",
        "\n",
        "print(tf.einsum(\"bij -> i\", batch_1), \"\\n\\n\") # Sum of all  elements in a batch row-wise"
      ],
      "metadata": {
        "id": "QUoVj5_UJ89K",
        "outputId": "6659a3ad-070c-4855-99d2-e3ea86494405",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(72, shape=(), dtype=int32) \n",
            "\n",
            "\n",
            "tf.Tensor([ 7 19 18 28], shape=(4,), dtype=int32) \n",
            "\n",
            "\n",
            "tf.Tensor([42  9 21], shape=(3,), dtype=int32) \n",
            "\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Common Functions"
      ],
      "metadata": {
        "id": "Yp1Mq2gdBQ4k"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.expand_dims(input, axis)` function in TensorFlow adds a new dimension to the tensor `input` at the specified `axis` position, effectively increasing the tensor's rank by one."
      ],
      "metadata": {
        "id": "cxJGIKm1BYtp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_three_d.shape)\n",
        "\n",
        "print(tf.expand_dims(tensor_three_d, axis=0).shape)\n",
        "extended_tensor = tf.expand_dims(tensor_three_d, axis=0)\n",
        "\n",
        "print(tf.expand_dims(tensor_three_d, axis=1).shape)"
      ],
      "metadata": {
        "id": "Or4jWJKRCYPS",
        "outputId": "a41165bc-803e-4c49-ab54-e58213b3d70f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(3, 2, 3)\n",
            "(1, 3, 2, 3)\n",
            "(3, 1, 2, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.squeeze(input, axis)` function in TensorFlow removes dimensions of size 1 from the tensor `input`. If the `axis` parameter is specified, it removes only the dimensions with size 1 along those specific axes; otherwise, it removes all singleton dimensions from the tensor."
      ],
      "metadata": {
        "id": "hHpbvw_kD5Up"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(extended_tensor.shape)\n",
        "\n",
        "print(tf.squeeze(extended_tensor, 0).shape)"
      ],
      "metadata": {
        "id": "osjbv8tvECPV",
        "outputId": "dec982c7-0e77-4eae-c308-e0f2a52fea7e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 3, 2, 3)\n",
            "(3, 2, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.reshape(tensor, shape)` function in TensorFlow changes the shape of the input tensor `tensor` to the specified `shape`, without altering the data. The new shape must be compatible with the **original number** of elements in the tensor."
      ],
      "metadata": {
        "id": "LjuX4dOOFqD5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_three_d, \"\\n\\n\")\n",
        "\n",
        "print(tf.reshape(tensor_three_d, shape=[2,3,3]), \"\\n\\n\")\n",
        "\n",
        "print(tf.reshape(tensor_three_d, shape=[2,-1,3])) # The second dimension is inferred automatically based on the number of elements and the other dimensions. TensorFlow calculates the size needed to make the total number of elements consistent with the original tensor."
      ],
      "metadata": {
        "id": "ydi7ZdhwFyvw",
        "outputId": "bec7c207-8a34-40fb-9144-11043d419a8d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[[ 1  2  0]\n",
            "  [ 3  5 -1]]\n",
            "\n",
            " [[10  2  0]\n",
            "  [ 1  0  2]]\n",
            "\n",
            " [[ 2  1  9]\n",
            "  [ 4 -3 32]]], shape=(3, 2, 3), dtype=int32) \n",
            "\n",
            "\n",
            "tf.Tensor(\n",
            "[[[ 1  2  0]\n",
            "  [ 3  5 -1]\n",
            "  [10  2  0]]\n",
            "\n",
            " [[ 1  0  2]\n",
            "  [ 2  1  9]\n",
            "  [ 4 -3 32]]], shape=(2, 3, 3), dtype=int32) \n",
            "\n",
            "\n",
            "tf.Tensor(\n",
            "[[[ 1  2  0]\n",
            "  [ 3  5 -1]\n",
            "  [10  2  0]]\n",
            "\n",
            " [[ 1  0  2]\n",
            "  [ 2  1  9]\n",
            "  [ 4 -3 32]]], shape=(2, 3, 3), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.concat(values, axis)` function in TensorFlow concatenates a list of tensors along a specified `axis`. The tensors in the `values` list must have the same shape, except in the dimension corresponding to the `axis` where they are concatenated."
      ],
      "metadata": {
        "id": "9agMOoGoUqMd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(mat_1, \"\\n\\n\", mat_2, \"\\n\\n\")\n",
        "\n",
        "tf.concat([mat_1, mat_2], 0)"
      ],
      "metadata": {
        "id": "LquD84bZU2O0",
        "outputId": "598018e9-fc09-4f11-aa9e-08bbab174019",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]], shape=(2, 3), dtype=int32) \n",
            "\n",
            " tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]\n",
            " [ 4  5  6]], shape=(3, 3), dtype=int32) \n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(5, 3), dtype=int32, numpy=\n",
              "array([[ 1,  2,  0],\n",
              "       [ 3,  5, -1],\n",
              "       [ 1,  2,  0],\n",
              "       [ 3,  5, -1],\n",
              "       [ 4,  5,  6]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.stack(values, axis)` function in TensorFlow stacks a list of tensors along a new axis, creating a higher-dimensional tensor. All tensors in the `values` list **must have the same shape**. The `axis` parameter specifies the dimension along which to stack the tensors, with a new dimension being added at this position in the output tensor."
      ],
      "metadata": {
        "id": "9CFV4SsoW2We"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(mat_1, \"\\n\\n\", mat_4, \"\\n\\n\")\n",
        "\n",
        "\n",
        "tf.stack([mat_1,mat_4], axis=0)"
      ],
      "metadata": {
        "id": "eg4kxLcoXBVn",
        "outputId": "febaaafa-0b0b-4769-eac8-76f87bb15bae",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]], shape=(2, 3), dtype=int32) \n",
            "\n",
            " tf.Tensor(\n",
            "[[ 1  1  2]\n",
            " [ 4 -2 -1]], shape=(2, 3), dtype=int32) \n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2, 3), dtype=int32, numpy=\n",
              "array([[[ 1,  2,  0],\n",
              "        [ 3,  5, -1]],\n",
              "\n",
              "       [[ 1,  1,  2],\n",
              "        [ 4, -2, -1]]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.pad(tensor, paddings, mode='CONSTANT')` function adds padding to a tensor based on the `paddings` configuration, extending the tensor's dimensions. The `mode` determines how the padding is applied, with `'CONSTANT'` (defaulting to 0) being the most common option.\n",
        "\n",
        "* `paddings`: A list or tensor of shape `[n, 2]`, where `n` is the rank of the input tensor. Each element specifies how much padding to add before and after the corresponding dimension of the tensor.\n",
        "\n",
        "* `mode`: The type of padding to apply. The default is `'CONSTANT'`, which pads with a constant value (default is 0). Other options include `'REFLECT'` (reflects the values on the edges) and `'SYMMETRIC'` (mirrors the values on the edges)."
      ],
      "metadata": {
        "id": "Pr8v3QwXa484"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = tf.constant([[1,2,3],\n",
        "                      [4,5,6]])\n",
        "\n",
        "paddings = tf.constant([[1,1], # Add 1 row of padding before and after the rows of the tensor.\n",
        "                        [2,2]]) # Add 2 columns of padding before and after the columns of the tensor.\n",
        "\n",
        "print(tf.pad(tensor, paddings, mode='CONSTANT'), \"\\n\\n\")\n",
        "\n",
        "print(tf.pad(tensor, paddings, mode='CONSTANT', constant_values=-1), \"\\n\\n\")\n",
        "\n",
        "print(tf.pad(tensor, paddings, mode='REFLECT'), \"\\n\\n\")\n",
        "\n",
        "print(tf.pad(tensor, paddings, mode='SYMMETRIC'), \"\\n\\n\")"
      ],
      "metadata": {
        "id": "nGQJWeSobbim",
        "outputId": "61d6d7e3-1aff-46c7-8553-26da3d84e720",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[0 0 0 0 0 0 0]\n",
            " [0 0 1 2 3 0 0]\n",
            " [0 0 4 5 6 0 0]\n",
            " [0 0 0 0 0 0 0]], shape=(4, 7), dtype=int32) \n",
            "\n",
            "\n",
            "tf.Tensor(\n",
            "[[-1 -1 -1 -1 -1 -1 -1]\n",
            " [-1 -1  1  2  3 -1 -1]\n",
            " [-1 -1  4  5  6 -1 -1]\n",
            " [-1 -1 -1 -1 -1 -1 -1]], shape=(4, 7), dtype=int32) \n",
            "\n",
            "\n",
            "tf.Tensor(\n",
            "[[6 5 4 5 6 5 4]\n",
            " [3 2 1 2 3 2 1]\n",
            " [6 5 4 5 6 5 4]\n",
            " [3 2 1 2 3 2 1]], shape=(4, 7), dtype=int32) \n",
            "\n",
            "\n",
            "tf.Tensor(\n",
            "[[2 1 1 2 3 3 2]\n",
            " [2 1 1 2 3 3 2]\n",
            " [5 4 4 5 6 6 5]\n",
            " [5 4 4 5 6 6 5]], shape=(4, 7), dtype=int32) \n",
            "\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "paddings = tf.constant([[1,0], # Add 1 row of padding before the rows of the tensor.\n",
        "                        [1,3]]) # Add 1 columns of padding before and 3 columns of padding after the columns of the tensor.\n",
        "\n",
        "\n",
        "print(tf.pad(tensor, paddings, mode='CONSTANT'))\n"
      ],
      "metadata": {
        "id": "6NdieukUdy6g",
        "outputId": "903e28eb-760b-4310-c545-bde31a42121d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[0 0 0 0 0 0 0]\n",
            " [0 1 2 3 0 0 0]\n",
            " [0 4 5 6 0 0 0]], shape=(3, 7), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.gather(params, indices, axis)` function in TensorFlow extracts elements from the `params` tensor along the specified `axis` according to the `indices` provided. The `indices` tensor specifies which elements to gather, and the result is a new tensor containing the selected elements from the original tensor.\n",
        "\n",
        "![image.png](data:image/png;base64,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)\n"
      ],
      "metadata": {
        "id": "ULpZTpije9WQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(mat_1, \"\\n\\n\")\n",
        "\n",
        "indices = [2,0]\n",
        "print(tf.gather(mat_1, indices, axis=1))"
      ],
      "metadata": {
        "id": "e96Rl_pUfHOi",
        "outputId": "a2a64d73-076d-4d0b-f435-7ef108a87014",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ 1  2  0]\n",
            " [ 3  5 -1]], shape=(2, 3), dtype=int32) \n",
            "\n",
            "\n",
            "tf.Tensor(\n",
            "[[ 0  1]\n",
            " [-1  3]], shape=(2, 2), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.gather_nd(params, indices)` function in TensorFlow gathers slices from the `params` tensor according to multi-dimensional indices specified in `indices`. Each entry in `indices` is a list of indices that specifies a slice to extract from `params`, allowing for complex and multi-dimensional indexing. The result is a tensor containing the gathered slices."
      ],
      "metadata": {
        "id": "BXvgS7khqBbY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_three_d, \"\\n\\n\")\n",
        "\n",
        "indices = [\n",
        "    [[0,0],\n",
        "     [2,1]]\n",
        "]\n",
        "\n",
        "tf.gather_nd(tensor_three_d, indices)"
      ],
      "metadata": {
        "id": "319CZus3qNDd",
        "outputId": "25216c53-83fe-4600-a6c0-432b2bcee78b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[[ 1  2  0]\n",
            "  [ 3  5 -1]]\n",
            "\n",
            " [[10  2  0]\n",
            "  [ 1  0  2]]\n",
            "\n",
            " [[ 2  1  9]\n",
            "  [ 4 -3 32]]], shape=(3, 2, 3), dtype=int32) \n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(1, 2, 3), dtype=int32, numpy=\n",
              "array([[[ 1,  2,  0],\n",
              "        [ 4, -3, 32]]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Ragged Tensors"
      ],
      "metadata": {
        "id": "V1hMA3cgei-q"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, `tf.ragged` is a module that provides support for working with ragged tensors, which are tensors with varying lengths along one or more dimensions. Unlike regular tensors, where every element in a given dimension must have the same size, ragged tensors can have elements of different sizes.\n",
        "\n",
        "Key components include:\n",
        "\n",
        "* `tf.RaggedTensor`: The main class representing a ragged tensor.\n",
        "\n",
        "* `tf.ragged.constant`: A function to create a ragged tensor from nested Python lists.\n",
        "\n",
        "* `tf.ragged.stack`: Similar to tf.stack, but for ragged tensors.\n",
        "\n",
        "* `tf.ragged.boolean_mask`: Applies a boolean mask to a ragged tensor."
      ],
      "metadata": {
        "id": "42cqsej4emtl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_two_d_ragged = tf.ragged.constant([\n",
        "    [1,2,3],\n",
        "    [4,5],\n",
        "    [6,7,8,9]\n",
        "])\n",
        "\n",
        "print(tensor_two_d_ragged)\n",
        "print(tensor_two_d_ragged.shape)"
      ],
      "metadata": {
        "id": "qtfx08cmf2a1",
        "outputId": "bc5ae42e-d539-4537-f312-cb6cac2f63bf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<tf.RaggedTensor [[1, 2, 3], [4, 5], [6, 7, 8, 9]]>\n",
            "(3, None)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.ragged.boolean_mask(data, mask)` function in TensorFlow selects elements from a ragged tensor `data` based on a boolean mask `mask`. The `mask` must have the same shape as `data` or be broadcastable to that shape. This function returns a new ragged tensor containing only the elements of `data` where the corresponding `mask` value is `True`, preserving the ragged structure."
      ],
      "metadata": {
        "id": "1NyA4Jf4geck"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_two_d_ragged, \"\\n\\n\")\n",
        "\n",
        "tf.ragged.boolean_mask(tensor_two_d_ragged,\n",
        "                       mask=[True, False, True]) # To select specific rows\n",
        "\n"
      ],
      "metadata": {
        "id": "McXJOrPpg3D1",
        "outputId": "4a2d7375-a03a-420c-a268-bcf0ea283f86",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<tf.RaggedTensor [[1, 2, 3], [4, 5], [6, 7, 8, 9]]> \n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.RaggedTensor [[1, 2, 3], [6, 7, 8, 9]]>"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A `tf.RaggedTensor` in TensorFlow is a type of tensor that allows for the representation of data with variable-length dimensions, meaning that different rows or slices can have different lengths. Unlike regular tensors, which require all dimensions to be of fixed size, a `RaggedTensor` is useful for handling data like sequences of varying lengths, such as sentences of different word counts or variable-sized image batches.\n",
        "\n",
        "Key features of RaggedTensor:\n",
        "\n",
        "* It allows different sub-arrays to have different lengths, providing flexibility in handling irregularly shaped data.\n",
        "\n",
        "* It can be created using the `tf.RaggedTensor.from_row_lengths()`, `tf.RaggedTensor.from_row_splits()`, or similar factory methods.\n",
        "\n",
        "* It supports many standard TensorFlow operations, while maintaining the ragged structure."
      ],
      "metadata": {
        "id": "vXf3fpnvj7Ao"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tf.RaggedTensor.from_row_lengths(\n",
        "    values=[3,1,4,1,5,9,2,6],\n",
        "    row_lengths=[4,0,3,1] # This list specifies how many elements should go into each row. The function goes through each value in row_lengths and slices off that many elements from values to form each row.\n",
        "))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Lb9cCOgFHjAR",
        "outputId": "84402159-b843-4426-c533-4c4e8e1fe01b"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6]]>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.RaggedTensor.from_row_limits()` function in TensorFlow creates a RaggedTensor by specifying row boundaries. Here's a breakdown of how `from_row_limits()` works:\n",
        "\n",
        "*   `values`: A 1D tensor containing all the elements of the ragged tensor in a flattened format.\n",
        "*   `row_limits`: A 1D tensor of row boundaries, where each element represents the exclusive ending index for each row. For example, if `row_limits = [3, 5, 7]`, the first row contains elements from values`[0:3]`, the second row from values`[3:5]`, and the third row from values`[5:7]`.\n",
        "\n"
      ],
      "metadata": {
        "id": "ECfz_LdMLNcV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tf.RaggedTensor.from_row_limits(\n",
        "    values=[3,1,4,1,5,9,2,6],\n",
        "    row_limits=[3,5,8]\n",
        "))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y-81xbg9KO1q",
        "outputId": "41fe84b7-f21f-46ab-8b8b-3b5669b9c24c"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<tf.RaggedTensor [[3, 1, 4], [1, 5], [9, 2, 6]]>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Sparse Tensors"
      ],
      "metadata": {
        "id": "x0_ACHYRNTNc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `tf.sparse.SparseTensor` function in TensorFlow creates a sparse tensor, which is a tensor where most elements are zero or missing. Sparse tensors are useful for efficiently storing and processing data with many zero entries, such as in natural language processing (NLP) or certain matrix computations.\n",
        "\n",
        "A `SparseTensor` is defined by three main components:\n",
        "\n",
        "1.   `indices`: A 2D tensor specifying the coordinates of non-zero elements in the sparse tensor. Each row is a unique coordinate represented as a list `[i, j, ...]` where `i`, `j`, etc., specify the position of the non-zero element in the respective dimension.\n",
        "2.   `values`: A 1D tensor containing the actual non-zero values of the sparse tensor, corresponding directly to the positions specified in `indices`.\n",
        "3.    `dense_shape`: A 1D tensor specifying the shape of the dense tensor that the sparse tensor represents (i.e., the \"full\" shape including the zero values).\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "1xSwpb9VNoTW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a 3x3 sparse tensor with non-zero values at specific indices\n",
        "tensor_sparse= tf.sparse.SparseTensor(\n",
        "    indices=[[0,0],[1,2],[2,1]],\n",
        "    values=[1,2,3],\n",
        "    dense_shape=[3,3]\n",
        ")\n",
        "\n",
        "print(tensor_sparse)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MpcgdB1cNXGv",
        "outputId": "e354599c-0f1e-4261-c684-fff851ac63d0"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "SparseTensor(indices=tf.Tensor(\n",
            "[[0 0]\n",
            " [1 2]\n",
            " [2 1]], shape=(3, 2), dtype=int64), values=tf.Tensor([1 2 3], shape=(3,), dtype=int32), dense_shape=tf.Tensor([3 3], shape=(2,), dtype=int64))\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.sparse.to_dense(tensor_sparse)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zhQ8ctZJQaat",
        "outputId": "6d7d024b-784d-4357-b681-5d2c1806f489"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              "array([[1, 0, 0],\n",
              "       [0, 0, 2],\n",
              "       [0, 3, 0]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### String Tensors"
      ],
      "metadata": {
        "id": "3f7gKrV_RCo3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, string tensors are tensors that hold strings as their data type. They work similarly to numeric tensors but store text instead of numbers. String tensors are useful for tasks involving text data, such as natural language processing (NLP) or handling categorical data represented as strings.\n",
        "\n",
        "Strings are stored as byte arrays in TensorFlow, hence each string is prefixed by `b` to indicate byte encoding (e.g., `b'hello'`)."
      ],
      "metadata": {
        "id": "CUr1hORORXh9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_string = tf.constant([\"hello\", \"I am\", \"a string\"])\n",
        "print(tensor_string)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hM12YtHpRG_9",
        "outputId": "27e73dc6-17c1-45ef-8b8c-071e6aca99cb"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([b'hello' b'I am' b'a string'], shape=(3,), dtype=string)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Operations on String Tensors:\n",
        "\n",
        "1.   Concatenation (`tf.strings.join()`)\n",
        "2.   Splitting (`tf.strings.split()`)\n",
        "3.   Length (`tf.strings.length()`)\n",
        "4.   Regex Matching (`tf.strings.regex_full_match()`)\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "ch8d6g9hR88W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "joined = tf.strings.join([tensor_string, tensor_string], separator=\", \")\n",
        "print(joined,\"\\n\\n\")\n",
        "\n",
        "split = tf.strings.split(tensor_string) # SparseTensor with split words for each string\n",
        "print(split,\"\\n\\n\")\n",
        "\n",
        "lengths = tf.strings.length(tensor_string)  # Tensor with lengths of each string\n",
        "print(lengths, \"\\n\\n\")\n",
        "\n",
        "matched = tf.strings.regex_full_match(tensor_string, \"I am*\")\n",
        "print(matched)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aqOkBEZTSowe",
        "outputId": "82e214ab-da5a-49a9-f5d2-3c258dc37ce2"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([b'hello, hello' b'I am, I am' b'a string, a string'], shape=(3,), dtype=string) \n",
            "\n",
            "\n",
            "<tf.RaggedTensor [[b'hello'], [b'I', b'am'], [b'a', b'string']]> \n",
            "\n",
            "\n",
            "tf.Tensor([5 4 8], shape=(3,), dtype=int32) \n",
            "\n",
            "\n",
            "tf.Tensor([False  True False], shape=(3,), dtype=bool)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Variables"
      ],
      "metadata": {
        "id": "jD72WQOXUawf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "`tf.Variable` in TensorFlow is a mutable tensor, meaning its values can be changed after initialization. This is different from `tf.constant`, which is immutable once created. `tf.Variable` is commonly used to represent weights, biases, and other parameters in machine learning models, as these values need to be updated during training.\n",
        "\n",
        "Key Features of `tf.Variable`\n",
        "\n",
        "1.   **Mutability**: Unlike `tf.constant`, which is immutable, a `tf.Variable` can be modified by reassigning its values.\n",
        "2.   **Tracking**: `tf.Variable` keeps track of its changes, which makes it suitable for use in optimization during training since TensorFlow can watch and update these values.\n",
        "3.  **Gradients**: `tf.Variable` is tracked by the automatic differentiation engine in TensorFlow, so gradients can be calculated for them, a crucial aspect for model training.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "QIQbDNJJYGZf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a tf.Variable with initial values\n",
        "my_var = tf.Variable(initial_value=[1.0, 2.0, 3.0], dtype=tf.float32, name='My_Var')\n",
        "print(my_var)"
      ],
      "metadata": {
        "id": "FBu9vAXLUc4c",
        "outputId": "7a00b82d-2fe0-48af-a02a-de5a4ca8ee4b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<tf.Variable 'My_Var:0' shape=(3,) dtype=float32, numpy=array([1., 2., 3.], dtype=float32)>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Modifying a `tf.Variable`:\n",
        "You can modify a `tf.Variable` using the `.assign()`,`.assign_add()`, or `assign_sub()` methods."
      ],
      "metadata": {
        "id": "rNLBHqlQZajo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assign a new value\n",
        "my_var.assign([4.0, 5.0, 6.0])\n",
        "print(my_var, \"\\n\\n\")\n",
        "\n",
        "# Increment each element by a specified value\n",
        "my_var.assign_add([1.0, 1.0, 1.0])\n",
        "print(my_var, \"\\n\\n\")\n",
        "\n",
        "# Decrement each element by a specified value\n",
        "my_var.assign_sub([2.0, 2.0, 0.5])\n",
        "print(my_var)"
      ],
      "metadata": {
        "id": "s6tnVGpiZhu7",
        "outputId": "70c2ce7c-fb60-4e92-b3cd-695201a497a7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<tf.Variable 'My_Var:0' shape=(3,) dtype=float32, numpy=array([4., 5., 6.], dtype=float32)> \n",
            "\n",
            "\n",
            "<tf.Variable 'My_Var:0' shape=(3,) dtype=float32, numpy=array([5., 6., 7.], dtype=float32)> \n",
            "\n",
            "\n",
            "<tf.Variable 'My_Var:0' shape=(3,) dtype=float32, numpy=array([3. , 4. , 6.5], dtype=float32)>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Runtime Hardware"
      ],
      "metadata": {
        "id": "jWhyoE9fb0ST"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "`tf.device()` is a TensorFlow context manager that specifies the device on which operations are executed. It allows you to control whether code runs on a CPU, GPU, or other accelerators (like TPUs) if available. This is useful for optimizing performance, as TensorFlow automatically uses GPUs when available, but you may want specific operations to run on different devices.\n",
        "\n",
        "The `tf.device()` context manager takes a device name (e.g., `\"/CPU:0\"` or `\"/GPU:0\"`) and applies it to all operations within its block."
      ],
      "metadata": {
        "id": "154gIQN8cE42"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Place a tensor on the CPU\n",
        "with tf.device(\"/CPU:0\"):\n",
        "    cpu_tensor = tf.constant([1.0, 2.0, 3.0])\n",
        "    print(cpu_tensor, cpu_tensor.device)\n",
        "\n",
        "with tf.device(\"/GPU:0\"):\n",
        "        gpu_tensor = tf.constant([4.0, 5.0, 6.0])\n",
        "        print(gpu_tensor, gpu_tensor.device)"
      ],
      "metadata": {
        "id": "QPDzM9HGcJCk",
        "outputId": "6ff6e8bb-dca0-43fa-d88f-6ae544db823c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([1. 2. 3.], shape=(3,), dtype=float32) /job:localhost/replica:0/task:0/device:CPU:0\n",
            "tf.Tensor([4. 5. 6.], shape=(3,), dtype=float32) /job:localhost/replica:0/task:0/device:GPU:0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Normalization"
      ],
      "metadata": {
        "id": "RURH5QltwoiI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In TensorFlow, the `Normalization()` layer is used to standardize input data by adjusting the mean and standard deviation. It applies a transformation to scale the data so that it has a mean of 0 and a standard deviation of 1, which can help improve model performance by making the data more comparable across features.\n",
        "\n",
        "Here’s a quick breakdown of how it works:\n",
        "\n",
        "1.   **Calculate Mean and Variance**: During the `adapt()` step, the `Normalization()` layer computes the mean and variance of the input data.\n",
        "2.   **Standardize Input Data**: When used in a model, it subtracts the mean and divides by the standard deviation for each input feature, producing normalized values.\n"
      ],
      "metadata": {
        "id": "f8dSsJClxVpR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you already know the `mean` and `standard deviation` of your data, you can initialize the `Normalization()` layer in TensorFlow with these values directly, skipping the `adapt()` step."
      ],
      "metadata": {
        "id": "7jAubk-OxwUz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.layers import Normalization\n",
        "\n",
        "# Known mean and standard deviation\n",
        "mean = [3.0, 4.0]\n",
        "stddev = [1.5, 1.5]\n",
        "\n",
        "# Create a Normalization layer with known mean and standard deviation\n",
        "normalizer = Normalization(mean=mean, variance=np.square(stddev))\n",
        "\n",
        "# Example data to normalize\n",
        "data = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], dtype=\"float32\")\n",
        "\n",
        "# Normalize the data\n",
        "normalized_data = normalizer(data)\n",
        "print(normalized_data)"
      ],
      "metadata": {
        "id": "iQc9BsQCwtP9",
        "outputId": "39179238-2838-4d37-a894-ae7dd93ac293",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[-1.3333334 -1.3333334]\n",
            " [ 0.         0.       ]\n",
            " [ 1.3333334  1.3333334]], shape=(3, 2), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Sample data\n",
        "data = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], dtype=\"float32\")\n",
        "\n",
        "# Create a Normalization layer\n",
        "normalizer = Normalization()\n",
        "\n",
        "# Fit the normalizer to the data\n",
        "normalizer.adapt(data)\n",
        "\n",
        "# Normalize a batch of data\n",
        "print(normalizer(data))"
      ],
      "metadata": {
        "id": "V3YCXSh2zk1e",
        "outputId": "c279392c-f0b3-457c-f37c-f3d94a180b9d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[-1.2247449 -1.2247449]\n",
            " [ 0.         0.       ]\n",
            " [ 1.2247449  1.2247449]], shape=(3, 2), dtype=float32)\n"
          ]
        }
      ]
    }
  ]
}