tensors_variables_d1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPJd/oPT+hjnA7Ko7m40HzB",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/sidhyaashu/DL_Computer_Vision/blob/master/tensors_variables_d1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Tensors"
      ],
      "metadata": {
        "id": "B9Jge9M5CvTc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "https://www.tensorflow.org/api_docs/python/tf"
      ],
      "metadata": {
        "id": "OPINOKeYVowl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf"
      ],
      "metadata": {
        "id": "6ips4OosCwoj"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_zero_d = tf.constant(4)\n",
        "print(tensor_zero_d)"
      ],
      "metadata": {
        "id": "Soh5iZ3hC1OI",
        "outputId": "62b4227d-cf83-4bd5-b529-8ab0102ebc6d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(4, shape=(), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_one_d = tf.constant([1,2,3,4,5,6])\n",
        "print(tensor_one_d)"
      ],
      "metadata": {
        "id": "792smLESC-q4",
        "outputId": "60b96754-9a02-47e7-843f-731150471f6f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([1 2 3 4 5 6], shape=(6,), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_two_d = tf.constant([\n",
        "    [1,2,3],\n",
        "    [4,5,6],\n",
        "    [7,8,9]\n",
        "])\n",
        "print(tensor_two_d)"
      ],
      "metadata": {
        "id": "eqYE-FEBDWNj",
        "outputId": "2dee3a91-0274-4bb9-ea35-b111b3c8ccb0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]], shape=(3, 3), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_three_d = tf.constant([\n",
        "    [\n",
        "        [1,2,3],\n",
        "        [4,5,6]\n",
        "    ],\n",
        "    [\n",
        "        [7,8,9],\n",
        "        [10,11,12]\n",
        "    ],\n",
        "    [\n",
        "        [13,14,15],\n",
        "        [16,17,18]\n",
        "    ]\n",
        "])\n",
        "\n",
        "print(tensor_three_d)"
      ],
      "metadata": {
        "id": "qG95yLqwDiZ_",
        "outputId": "e1079f33-9a00-4e91-8986-d436083c3c39",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "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]]], shape=(3, 2, 3), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor_three_d.ndim)"
      ],
      "metadata": {
        "id": "M_DiU2e5EJtA",
        "outputId": "786a1ea8-1cd2-4ba9-adfd-6fb0d1ce954f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_four_d = tf.constant([\n",
        "    [\n",
        "    [\n",
        "        [1,2,3],\n",
        "        [4,5,6]\n",
        "    ],\n",
        "    [\n",
        "        [7,8,9],\n",
        "        [10,11,12]\n",
        "    ],\n",
        "    [\n",
        "        [13,14,15],\n",
        "        [16,17,18]\n",
        "    ]\n",
        "],\n",
        "    [\n",
        "    [\n",
        "        [1,2,3],\n",
        "        [4,5,6]\n",
        "    ],\n",
        "    [\n",
        "        [7,8,9],\n",
        "        [10,11,12]\n",
        "    ],\n",
        "    [\n",
        "        [13,14,15],\n",
        "        [16,17,18]\n",
        "    ]\n",
        "],[\n",
        "    [\n",
        "        [1,2,3],\n",
        "        [4,5,6]\n",
        "    ],\n",
        "    [\n",
        "        [7,8,9],\n",
        "        [10,11,12]\n",
        "    ],\n",
        "    [\n",
        "        [13,14,15],\n",
        "        [16,17,18]\n",
        "    ]\n",
        "]\n",
        "])\n",
        "\n",
        "print(tensor_four_d.ndim)"
      ],
      "metadata": {
        "id": "ch81IshaEkPK",
        "outputId": "882bedcb-f753-4621-fdf6-e3e38a5b5f43",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "J27lK1wSFJs3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "hiCfyn8hJbOh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Convert Numpy To Tensor"
      ],
      "metadata": {
        "id": "ZnyLDG6MJb1O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n"
      ],
      "metadata": {
        "id": "Orw2KNEgJhEy"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np_array = np.array([1,2,3,4])\n",
        "print(np_array)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p2e0e9xiJkjd",
        "outputId": "dad33ad7-cfb2-4f13-99b5-394517a29d2a"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "converted_array = tf.convert_to_tensor(np_array)\n",
        "print(converted_array)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ofnjrnc3J25e",
        "outputId": "ce7092bd-8e1b-44cf-d265-d0b034c49a8a"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([1 2 3 4], shape=(4,), dtype=int64)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Construct an identity matrix https://www.tensorflow.org/api_docs/python/tf/eye\n",
        "eye_tensor = tf.eye(\n",
        "    4,\n",
        "    num_columns=None,\n",
        "    batch_shape=None,\n",
        "    dtype=tf.dtypes.float32,\n",
        "    name=None\n",
        ")\n",
        "print(eye_tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t4KwEKjdJ8jf",
        "outputId": "5fb7e23f-6d38-4aeb-cd6d-216c9dcf5d17"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[1. 0. 0. 0.]\n",
            " [0. 1. 0. 0.]\n",
            " [0. 0. 1. 0.]\n",
            " [0. 0. 0. 1.]], shape=(4, 4), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "eye_tensor = tf.eye(\n",
        "    4,\n",
        "    num_columns=None,\n",
        "    batch_shape=[4,],\n",
        "    dtype=tf.dtypes.float32,\n",
        "    name=None\n",
        ")\n",
        "print(eye_tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4oBiAx52KVvD",
        "outputId": "3dc5e66a-69dd-4a39-d3e4-9ea044236383"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[[1. 0. 0. 0.]\n",
            "  [0. 1. 0. 0.]\n",
            "  [0. 0. 1. 0.]\n",
            "  [0. 0. 0. 1.]]\n",
            "\n",
            " [[1. 0. 0. 0.]\n",
            "  [0. 1. 0. 0.]\n",
            "  [0. 0. 1. 0.]\n",
            "  [0. 0. 0. 1.]]\n",
            "\n",
            " [[1. 0. 0. 0.]\n",
            "  [0. 1. 0. 0.]\n",
            "  [0. 0. 1. 0.]\n",
            "  [0. 0. 0. 1.]]\n",
            "\n",
            " [[1. 0. 0. 0.]\n",
            "  [0. 1. 0. 0.]\n",
            "  [0. 0. 1. 0.]\n",
            "  [0. 0. 0. 1.]]], shape=(4, 4, 4), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Creates a tensor filled with a scalar value. https://www.tensorflow.org/api_docs/python/tf/fill\n",
        "\"\"\"tf.fill(\n",
        "    dims, value, name=None, layout=None\n",
        ")\"\"\"\n",
        "\n",
        "fill_tensor = tf.fill(\n",
        "    [3,4], 5, name=None, layout=None\n",
        ")\n",
        "print(fill_tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8NO9AVodKuuG",
        "outputId": "07bd3e5f-4391-4c16-b068-ad3afa1bee00"
      },
      "execution_count": 10,
      "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": "code",
      "source": [
        "#Creates a tensor with all elements set to one (1). https://www.tensorflow.org/api_docs/python/tf/ones\n",
        "tf_ones = tf.ones(\n",
        "    [3,2,3],\n",
        "    dtype=tf.dtypes.float32,\n",
        "    name=None,\n",
        "    layout=None\n",
        ")\n",
        "\n",
        "print(tf_ones)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x-0UrTjELcGb",
        "outputId": "a1282de1-25b4-4226-ecf2-5fa30bf20f6e"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[[1. 1. 1.]\n",
            "  [1. 1. 1.]]\n",
            "\n",
            " [[1. 1. 1.]\n",
            "  [1. 1. 1.]]\n",
            "\n",
            " [[1. 1. 1.]\n",
            "  [1. 1. 1.]]], shape=(3, 2, 3), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Creates a tensor of all ones that has the same shape as the input. https://www.tensorflow.org/api_docs/python/tf/ones_like\n",
        "\n",
        "tf_ones_like = tf.ones_like(\n",
        "    tf_ones, dtype=None, name=None, layout=None\n",
        ")\n",
        "\n",
        "print( tf_ones_like)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z133o_-7Lyhu",
        "outputId": "1f2f4d7b-9f65-4583-e2ff-fe6ca37a7bfc"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[[1. 1. 1.]\n",
            "  [1. 1. 1.]]\n",
            "\n",
            " [[1. 1. 1.]\n",
            "  [1. 1. 1.]]\n",
            "\n",
            " [[1. 1. 1.]\n",
            "  [1. 1. 1.]]], shape=(3, 2, 3), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Another methods are\n",
        "zeros,\n",
        "zeros_like,\n",
        "shap,\n",
        "Rank,\n",
        "size"
      ],
      "metadata": {
        "id": "P7hzaGK-M2Kj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Random Normal Distribution"
      ],
      "metadata": {
        "id": "YrlvpyCeN0A9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# https://www.tensorflow.org/api_docs/python/tf/random"
      ],
      "metadata": {
        "id": "u1hsPHJNM1TC"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Outputs random values from a normal distribution.\n",
        "# https://www.acsu.buffalo.edu/~adamcunn/probability/normal.html  playGround normal distribution\n",
        "\n",
        "tf_normal_random = tf.random.normal(\n",
        "    [3,2],\n",
        "    mean=0.0,\n",
        "    stddev=1.0,\n",
        "    dtype=tf.dtypes.float32,\n",
        "    seed=None,\n",
        "    name=None\n",
        ")\n",
        "\n",
        "print(tf_normal_random)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8HawFVwLOKX7",
        "outputId": "a6d0f1b3-318e-485e-9688-43e7b75bf0c7"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[-0.23784274  1.040484  ]\n",
            " [ 0.6539853  -1.693266  ]\n",
            " [-1.6516482  -1.5349246 ]], shape=(3, 2), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "CS-2FyoxOeyD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "FpyFUpLcQWxF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "jCKfhp74QWnd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "a32u1yItQWZn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# INDEXING"
      ],
      "metadata": {
        "id": "E6-yciaKQX6i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_index = tf.constant([1,2,3,4,5,6])\n",
        "print(tensor_index)\n",
        "print(tensor_index[1:4])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_lZB4dKDQaa4",
        "outputId": "0ba1a172-ce99-4b65-fb5f-1dc21137df7d"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([1 2 3 4 5 6], shape=(6,), dtype=int32)\n",
            "tf.Tensor([2 3 4], shape=(3,), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.range( 1,10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gL95tjTTQ-lj",
        "outputId": "f5d9d616-280e-4ffb-9fdc-65521e6825e4"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(9,), dtype=int32, numpy=array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor_two_d = tf.constant([\n",
        "    [1,2,3],\n",
        "    [4,5,6],\n",
        "    [7,8,9]\n",
        "])\n",
        "print(tensor_two_d[:2 ,:2 ])\n",
        "print(\"\\n\")\n",
        "print(tensor_two_d[2 ,:2 ])\n",
        "print(\"\\n\")\n",
        "print(tensor_two_d[2 ,2 ])\n",
        "print(\"\\n\")\n",
        "print(tensor_two_d[:,2 ])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QJ9WEMRlSUIr",
        "outputId": "2e0b6b7b-4d00-4fbc-dd15-2bc8e7f44ce2"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[1 2]\n",
            " [4 5]], shape=(2, 2), dtype=int32)\n",
            "\n",
            "\n",
            "tf.Tensor([7 8], shape=(2,), dtype=int32)\n",
            "\n",
            "\n",
            "tf.Tensor(9, shape=(), dtype=int32)\n",
            "\n",
            "\n",
            "tf.Tensor([3 6 9], shape=(3,), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "fVIRGP0uUgaI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Ntp7fH-0VXFs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "cds9R8-kVXYV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# MATH"
      ],
      "metadata": {
        "id": "zLWtrjBiVYZ8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# https://www.tensorflow.org/api_docs/python/tf/math"
      ],
      "metadata": {
        "id": "Z7iKtjEoVZ9g"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Computes the absolute value of a tensor.\n",
        "x = -5\n",
        "print(\n",
        "    tf.math.abs(\n",
        "    x, name=None\n",
        ")\n",
        ")\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8tANCfZZVrmU",
        "outputId": "3a4d8e12-6522-4b91-8fff-5680ea4b1947"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(5, shape=(), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# omputes the power of one value to another.\n",
        "print(\n",
        "    tf.math.pow(\n",
        "    2, 3, name=None\n",
        ")\n",
        ")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J0YMGAqeWGMC",
        "outputId": "e7803571-2e15-466c-f77f-7e4f870d53ff"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(8, shape=(), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Computes a safe divide which returns 0 if y (denominator) is zero.\n",
        "print(\n",
        "    tf.math.divide_no_nan(\n",
        "    1.0, 0.0\n",
        ")\n",
        ")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "liLZQbJdWUes",
        "outputId": "eef6a6c0-580e-4946-d224-f65a464e5d63"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(0.0, shape=(), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Divides x / y elementwise, rounding toward the most negative integer.\n",
        "print(\n",
        "    tf.math.floordiv(\n",
        "    10, 3, name=None\n",
        ")\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HVYoegnNWsQk",
        "outputId": "0db8c69b-076f-4dca-cec5-7a4e50a27753"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(3, shape=(), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Returns the index with the largest value across axes of a tensor.  https://www.tensorflow.org/api_docs/python/tf/math/argmax\n",
        "\n",
        "x_argmax = tf.math.argmax(\n",
        "    [\n",
        "    [1,10,3],\n",
        "    [4,5,6],\n",
        "    [7,8,9]\n",
        "]\n",
        ")\n",
        "\n",
        "print(x_argmax.shape)\n",
        "print(x_argmax,0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tWUlM_VyaqZG",
        "outputId": "0575e7b1-d8f8-4d38-88de-b91af3439920"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(3,)\n",
            "tf.Tensor([2 0 2], shape=(3,), dtype=int64) 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x_argmax = tf.math.argmax(\n",
        "    [\n",
        "    [1,10,3],\n",
        "    [4,5,6],\n",
        "    [7,28,9]\n",
        "],\n",
        "    axis=1\n",
        ")\n",
        "\n",
        "print(x_argmax)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-vbmc6OAXCT6",
        "outputId": "03389210-7caf-498c-ead2-9651ce47c50c"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([1 2 1], shape=(3,), dtype=int64)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "l8QJF88xbk_L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "cKnpMq1kb2Bt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "v1sLVDfKdSxG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Linear algebra"
      ],
      "metadata": {
        "id": "o8LHlpLkehYx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# https://www.tensorflow.org/api_docs/python/tf/linalg"
      ],
      "metadata": {
        "id": "xEw67CpUej20"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Matrix multiplication\n",
        "matrix_u = tf.constant([\n",
        "    [1,2,3],\n",
        "    [4,5,6],\n",
        "    [7,8,9]\n",
        "])\n",
        "matrix_v = tf.constant([\n",
        "    [9,8,7],\n",
        "    [6,5,4],\n",
        "    [3,2,1]\n",
        "])\n",
        "mat_mul = tf.linalg.matmul(\n",
        "    matrix_u,\n",
        "    matrix_v,\n",
        "    transpose_a=False,\n",
        "    transpose_b=False,\n",
        "    adjoint_a=False,\n",
        "    adjoint_b=False,\n",
        "    a_is_sparse=False,\n",
        "    b_is_sparse=False,\n",
        "    name=None\n",
        ")\n",
        "print(mat_mul)\n",
        "# Computes the determinant of one or more square matrices.\n",
        "matrix_2_2 = tf.constant([\n",
        "    [1,2],\n",
        "    [3,4]\n",
        "], dtype=tf.float32)\n",
        "print(tf.linalg.det(matrix_2_2))\n",
        "# Computes the sign and the log of the absolute value of the determinant of one or more square matrices.\n",
        "sign , log_abs_det  = tf.linalg.slogdet(\n",
        "    matrix_2_2, name=None\n",
        ")\n",
        "print(sign,log_abs_det)\n",
        "# Computes the inverse of one or more square invertible matrices or their adjoints (conjugate transposes).\n",
        "matrix_inv = tf.linalg.inv(\n",
        "    matrix_2_2, adjoint=False, name=None\n",
        ")\n",
        "print(matrix_inv)\n",
        "# Solves systems of linear equations.\n",
        "x = tf.linalg.solve(\n",
        "    matrix_2_2,\n",
        "    [\n",
        "        [1,0],\n",
        "        [0,1]\n",
        "    ],\n",
        "    adjoint=False, name=None\n",
        ")\n",
        "print(x)\n",
        "# Computes the eigenvalues of one or more matrices.\n",
        "e , v = tf.linalg.eig(\n",
        "    matrix_2_2, name=None\n",
        ")\n",
        "print(e,v)\n",
        "# Computes the singular value decompositions of one or more matrices.\n",
        "s,u,v = tf.linalg.svd(\n",
        "    matrix_2_2, full_matrices=False, compute_uv=True, name=None\n",
        ")\n",
        "print(s,u,v)\n",
        "# QR Decomposition\n",
        "q,r = tf.linalg.qr(\n",
        "    matrix_2_2, full_matrices=False, name=None\n",
        ")\n",
        "print(q,r)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0jxIISv4hLU1",
        "outputId": "fbc10ef1-1135-4d6a-dae7-ccc6658081c9"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[ 30  24  18]\n",
            " [ 84  69  54]\n",
            " [138 114  90]], shape=(3, 3), dtype=int32)\n",
            "tf.Tensor(-2.0, shape=(), dtype=float32)\n",
            "tf.Tensor(-1.0, shape=(), dtype=float32) tf.Tensor(0.6931472, shape=(), dtype=float32)\n",
            "tf.Tensor(\n",
            "[[-2.0000002   1.0000001 ]\n",
            " [ 1.5000001  -0.50000006]], shape=(2, 2), dtype=float32)\n",
            "tf.Tensor(\n",
            "[[-2.0000002   1.0000001 ]\n",
            " [ 1.5000001  -0.50000006]], shape=(2, 2), dtype=float32)\n",
            "tf.Tensor([-0.37228122+0.j  5.372281  +0.j], shape=(2,), dtype=complex64) tf.Tensor(\n",
            "[[-0.8245648 +0.j -0.41597357+0.j]\n",
            " [ 0.56576747+0.j -0.90937674+0.j]], shape=(2, 2), dtype=complex64)\n",
            "tf.Tensor([5.4649854  0.36596614], shape=(2,), dtype=float32) tf.Tensor(\n",
            "[[ 0.4045535 -0.9145143]\n",
            " [ 0.9145143  0.4045535]], shape=(2, 2), dtype=float32) tf.Tensor(\n",
            "[[ 0.5760484  0.8174156]\n",
            " [ 0.8174156 -0.5760484]], shape=(2, 2), dtype=float32)\n",
            "tf.Tensor(\n",
            "[[-0.3162278  -0.9486833 ]\n",
            " [-0.9486833   0.31622773]], shape=(2, 2), dtype=float32) tf.Tensor(\n",
            "[[-3.1622777  -4.4271884 ]\n",
            " [ 0.         -0.63245535]], shape=(2, 2), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Sparse Tensor"
      ],
      "metadata": {
        "id": "j7g56K4Ts0AK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# https://www.tensorflow.org/api_docs/python/tf/linalg/band_part"
      ],
      "metadata": {
        "id": "CooI9bontikd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Sparse Tensor\n",
        "# A sparse tensor is a tensor that has a majority of its elements as zero.\n",
        "# This allows for efficient storage and computation, as only the non-zero elements and their indices need to be stored.\n"
      ],
      "metadata": {
        "id": "IMgnOJt4tBUa"
      },
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# Create a sparse tensor\n",
        "sparse_tensor = tf.sparse.SparseTensor(\n",
        "    indices=[[0, 0], [1, 2]],\n",
        "    values=[1, 2],\n",
        "    dense_shape=[3, 4]\n",
        ")\n",
        "\n",
        "# Convert to dense tensor\n",
        "dense_tensor = tf.sparse.to_dense(sparse_tensor)\n",
        "print(dense_tensor)\n",
        "\n",
        "# Sparse matrix multiplication\n",
        "sparse_matrix_a = tf.sparse.SparseTensor(\n",
        "    indices=[[0, 0], [1, 1]],\n",
        "    values=[1, 2],\n",
        "    dense_shape=[2, 2]\n",
        ")\n",
        "dense_matrix_b = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)\n",
        "result = tf.sparse.sparse_dense_matmul(sparse_matrix_a, dense_matrix_b)\n",
        "print(result)\n"
      ],
      "metadata": {
        "id": "Yt5cX9GCthZT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Ragged Tensor"
      ],
      "metadata": {
        "id": "ND81k_Al-uPe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# Ragged Tensors\n",
        "# A ragged tensor is a tensor with variable-length dimensions.\n",
        "# This is useful for representing data with irregular shapes, such as text or time series data.\n",
        "\n",
        "# Create a ragged tensor\n",
        "ragged_tensor = tf.ragged.constant([[1, 2], [3, 4, 5], [6]])\n",
        "\n",
        "# Access elements\n",
        "print(ragged_tensor[0])  # Output: [1, 2]\n",
        "print(ragged_tensor[1])  # Output: [3, 4, 5]\n",
        "\n",
        "# Convert to dense tensor\n",
        "dense_tensor = ragged_tensor.to_tensor()\n",
        "print(dense_tensor)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aIo16BJL-T4r",
        "outputId": "b0c6af27-05fc-40eb-9a2d-ddccc5f18a24"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([1 2], shape=(2,), dtype=int32)\n",
            "tf.Tensor([3 4 5], shape=(3,), dtype=int32)\n",
            "tf.Tensor(\n",
            "[[1 2 0]\n",
            " [3 4 5]\n",
            " [6 0 0]], shape=(3, 3), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# tf.sparse.SparseTensor\n",
        "\"\"\"\n",
        "tf.sparse.SparseTensor(\n",
        "    indices, values, dense_shape\n",
        ")\n",
        "\"\"\"\n",
        "x = tf.sparse.SparseTensor(indices=[[1, 1], [3, 4]], values=[8, 5], dense_shape=[5, 6])\n",
        "\n",
        "# Create a sparse tensor from a dense tensor\n",
        "print(x)\n",
        "\n",
        "print(tf.sparse.to_dense(x))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4Hd0ZjzO_yY0",
        "outputId": "ce4180c7-cfa5-4ac7-c21b-934c9d242663"
      },
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "SparseTensor(indices=tf.Tensor(\n",
            "[[1 1]\n",
            " [3 4]], shape=(2, 2), dtype=int64), values=tf.Tensor([8 5], shape=(2,), dtype=int32), dense_shape=tf.Tensor([5 6], shape=(2,), dtype=int64))\n",
            "tf.Tensor(\n",
            "[[0 0 0 0 0 0]\n",
            " [0 8 0 0 0 0]\n",
            " [0 0 0 0 0 0]\n",
            " [0 0 0 0 5 0]\n",
            " [0 0 0 0 0 0]], shape=(5, 6), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Text Tensor"
      ],
      "metadata": {
        "id": "-0p_2_bA-p9q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# Text tensors\n",
        "# Text tensors are used to represent text data in TensorFlow.\n",
        "# They can be created from strings, lists of strings, or other text-like data.\n",
        "\n",
        "# Create a text tensor from a string\n",
        "text_tensor = tf.constant(\"Hello, world!\")\n",
        "\n",
        "# Create a text tensor from a list of strings\n",
        "text_tensor_list = tf.constant([\"Hello\", \"world!\"])\n",
        "\n",
        "# Tokenize text\n",
        "tokenizer = tf.keras.preprocessing.text.Tokenizer()\n",
        "tokenizer.fit_on_texts([\"Hello, world!\"])\n",
        "text_sequences = tokenizer.texts_to_sequences([\"Hello, world!\"])\n",
        "print(text_sequences)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0lRZMLFT-evo",
        "outputId": "a42c8112-4b29-4b17-a161-9ff5824db6ed"
      },
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1, 2]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Copy a tensor setting everything outside a central band in each innermost matrix to zero."
      ],
      "metadata": {
        "id": "BQ5ELmBZs2-q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tf.linalg.band_part(\n",
        "    input: Annotated[Any, TV_MatrixBandPart_T],\n",
        "    num_lower: Annotated[Any, TV_MatrixBandPart_Tindex],\n",
        "    num_upper: Annotated[Any, TV_MatrixBandPart_Tindex],\n",
        "    name=None\n",
        ") -> Annotated[Any, TV_MatrixBandPart_T]\n",
        "\n"
      ],
      "metadata": {
        "id": "L8p8l7cFtxzT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The band part is computed as follows: Assume input has k dimensions [I, J, K, ..., M, N], then the output is a tensor with the same shape where\n",
        "\n",
        "band[i, j, k, ..., m, n] = in_band(m, n) * input[i, j, k, ..., m, n].\n",
        "\n",
        "The indicator function\n",
        "\n",
        "in_band(m, n) = (num_lower < 0 || (m-n) <= num_lower)) && (num_upper < 0 || (n-m) <= num_upper)."
      ],
      "metadata": {
        "id": "C3bGioq5uAQg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# if 'input' is [[ 0,  1,  2, 3]\n",
        "#                [-1,  0,  1, 2]\n",
        "#                [-2, -1,  0, 1]\n",
        "#                [-3, -2, -1, 0]],"
      ],
      "metadata": {
        "id": "_hBly8L5uBKV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "input = tf.constant([\n",
        "    [ 0,  1,  2, 3],\n",
        "                [-1,  0,  1, 2],\n",
        "                [-2, -1,  0, 1],\n",
        "                [-3, -2, -1, 0]])"
      ],
      "metadata": {
        "id": "7EbNE3IDufBz"
      },
      "execution_count": 48,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tf.linalg.band_part(input, 1, -1)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "89z9M-zEuFJc",
        "outputId": "c8fe6e27-4e7f-4411-a4f6-32c8f8f39dd6"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(4, 4), dtype=int32, numpy=\n",
              "array([[ 0,  1,  2,  3],\n",
              "       [-1,  0,  1,  2],\n",
              "       [ 0, -1,  0,  1],\n",
              "       [ 0,  0, -1,  0]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#  tf.linalg.band_part(input, 0, -1) ==> Upper triangular part.\n",
        "#  tf.linalg.band_part(input, -1, 0) ==> Lower triangular part.\n",
        "#  tf.linalg.band_part(input, 0, 0) ==> Diagonal."
      ],
      "metadata": {
        "id": "cVa4xCebuJg9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "727IJuYnu2mr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tf.linalg.band_part(input, 0, -1)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DCSVgcMovH3q",
        "outputId": "2031ee5e-3fc1-4fad-84cf-53b179b4e3d9"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(4, 4), dtype=int32, numpy=\n",
              "array([[0, 1, 2, 3],\n",
              "       [0, 0, 1, 2],\n",
              "       [0, 0, 0, 1],\n",
              "       [0, 0, 0, 0]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.linalg.band_part(input, -1, 0)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BAzJytlgvI_9",
        "outputId": "f6b39271-a00f-423d-aa15-797dc30463f3"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(4, 4), dtype=int32, numpy=\n",
              "array([[ 0,  0,  0,  0],\n",
              "       [-1,  0,  0,  0],\n",
              "       [-2, -1,  0,  0],\n",
              "       [-3, -2, -1,  0]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.linalg.band_part(input, 0, 0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KaD4voROvLge",
        "outputId": "c2399f2f-be80-4e88-ab43-40f5c158cc65"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(4, 4), dtype=int32, numpy=\n",
              "array([[0, 0, 0, 0],\n",
              "       [0, 0, 0, 0],\n",
              "       [0, 0, 0, 0],\n",
              "       [0, 0, 0, 0]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "cPHPGWBvvM0B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Computes the inverse of one or more square invertible matrices or their adjoints (conjugate transposes)."
      ],
      "metadata": {
        "id": "fqX45Tq8vXY1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# https://www.tensorflow.org/api_docs/python/tf/linalg/inv"
      ],
      "metadata": {
        "id": "TMNzVNDIvZQg"
      },
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Define a square invertible matrix\n",
        "matrix = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)\n",
        "\n",
        "# Compute the inverse of the matrix\n",
        "inverse_matrix = tf.linalg.inv(matrix)\n",
        "\n",
        "# Print the inverse matrix\n",
        "print(inverse_matrix)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PcGPMLuyvboz",
        "outputId": "1a84033f-09ed-43fb-f342-bbeafc11e216"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[-2.0000002   1.0000001 ]\n",
            " [ 1.5000001  -0.50000006]], shape=(2, 2), dtype=float32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "35u-l5_Lvh3l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# EINSUM OPERATOR"
      ],
      "metadata": {
        "id": "PaInkWcyyLmP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The einsum operator is a powerful and flexible tool for performing tensor operations, including matrix multiplications, in a compact and readable way. It uses Einstein summation convention to specify how tensors should be multiplied and summed."
      ],
      "metadata": {
        "id": "yFOc8gBTzDtK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "A = np.array([[1, 2], [3, 4]])  # Example matrix A of shape (2, 2)\n",
        "B = np.array([[5, 6], [7, 8]])  # Example matrix B of shape (2, 2)\n",
        "print(np.matmul(A,B))\n",
        "print(\"\\n\")\n",
        "C = np.einsum('ij,jk->ik', A, B)\n",
        "print(C)  # Output will be [[19 22], [43 50]]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rKmG3DUhyPDt",
        "outputId": "e2895573-9e5f-4491-c130-068b2219fc02"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[19 22]\n",
            " [43 50]]\n",
            "\n",
            "\n",
            "[[19 22]\n",
            " [43 50]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "A = np.array([[1, 2], [3, 4]])  # Example matrix A of shape (2, 2)\n",
        "B = np.array([[5, 6], [7, 8]])  # Example matrix B of shape (2, 2)\n",
        "print(A*B)\n",
        "print(\"\\n\")\n",
        "C = np.einsum('ij,ij->ij', A, B)\n",
        "print(C)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0ovEsRdUyQGk",
        "outputId": "18ab8c51-a9e8-481f-c133-1316efa752b9"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 5 12]\n",
            " [21 32]]\n",
            "\n",
            "\n",
            "[[ 5 12]\n",
            " [21 32]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "A = np.array([[1, 2], [3, 4]])\n",
        "\n",
        "print(A.T)\n",
        "print(\"\\n\")\n",
        "C = np.einsum('ij->ji', A)\n",
        "print(C)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "16cRKQ4Xy8a7",
        "outputId": "edbe6f58-6fda-4faf-926a-3d2f5be48603"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 3]\n",
            " [2 4]]\n",
            "\n",
            "\n",
            "[[1 3]\n",
            " [2 4]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Matrix multiplication using tf.matmul\n",
        "matrix_u = tf.constant([\n",
        "    [1, 2],\n",
        "    [3, 4]\n",
        "])\n",
        "matrix_v = tf.constant([\n",
        "    [5, 6],\n",
        "    [7, 8]\n",
        "])\n",
        "result = tf.matmul(matrix_u, matrix_v)\n",
        "print(result)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AwXU6TPtzZk0",
        "outputId": "6a8cbca3-8212-4372-88e1-e1610524e187"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[19 22]\n",
            " [43 50]], shape=(2, 2), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "import numpy as np\n",
        "A = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])  # Example 3D array A of shape (2, 2, 2)\n",
        "B = np.array([[[9, 10], [11, 12]], [[13, 14], [15, 16]]])  # Example 3D array B of shape (2, 2, 2)\n",
        "\n",
        "# Matrix multiplication along the last two dimensions using np.einsum\n",
        "C = np.einsum('ijk,ikl->ijl', A, B)\n",
        "print(C)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HkcFF45M0AUH",
        "outputId": "1160d407-4abc-4210-a87a-93fd0ac79bec"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[ 31  34]\n",
            "  [ 71  78]]\n",
            "\n",
            " [[155 166]\n",
            "  [211 226]]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "1hl60fD102g0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "-jEDIkRL4Zc6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Uza7uLnz4Zwd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# COMMON TENSORFLOW *FUNCTION*"
      ],
      "metadata": {
        "id": "5b18z21q4aiw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Returns a tensor with a length 1 axis inserted at index axis.\n",
        "# https://www.tensorflow.org/api_docs/python/tf/expand_dims"
      ],
      "metadata": {
        "id": "VPzxpywQ4eVv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Imagine you have a list of numbers (a 1D array) and you want to turn it into a table (a 2D array) by adding an extra dimension. expand_dims lets you do this easily."
      ],
      "metadata": {
        "id": "hXss8nv55Lj4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = tf.constant([1, 2, 3])\n",
        "print(tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zNTFonTL5KFM",
        "outputId": "0ce0df69-e023-41e6-a16e-40d3b364086c"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([1 2 3], shape=(3,), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "expanded_tensor = tf.expand_dims(tensor, axis=0)\n",
        "print(expanded_tensor)  # Output: [[1, 2, 3]]\n",
        "print(expanded_tensor.shape)  # Output: (1, 3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2ycdF1J85Wy4",
        "outputId": "b5138a0f-1d31-40ad-bfb2-424bfc720d2d"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor([[1 2 3]], shape=(1, 3), dtype=int32)\n",
            "(1, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Squeeze , reshape , concat ,"
      ],
      "metadata": {
        "id": "sdL_bDGb6WMq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# Removes dimensions of size 1 from the shape of a tensor.\n",
        "# https://www.tensorflow.org/api_docs/python/tf/squeeze\n",
        "# Imagine you have a box that's too big for its contents. squeeze helps you remove the extra empty space, making the box fit snugly around its contents.\n",
        "tensor = tf.constant([[[1], [2], [3]]])\n",
        "print(tensor.shape)  # Output: (1, 3, 1)\n",
        "squeezed_tensor = tf.squeeze(tensor)\n",
        "print(squeezed_tensor)  # Output: [1 2 3]\n",
        "print(squeezed_tensor.shape)  # Output: (3,)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D0Fr68rE5aia",
        "outputId": "9d445255-bf71-45b5-9504-74c96b048219"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 3, 1)\n",
            "tf.Tensor([1 2 3], shape=(3,), dtype=int32)\n",
            "(3,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Reshapes a tensor.\n",
        "# https://www.tensorflow.org/api_docs/python/tf/reshape\n",
        "# Imagine you have a lump of clay. reshape lets you mold it into different shapes without changing the amount of clay you have.\n",
        "tensor = tf.constant([1, 2, 3, 4, 5, 6])\n",
        "reshaped_tensor = tf.reshape(tensor, shape=(2, 3))\n",
        "print(reshaped_tensor)  # Output: [[1 2 3], [4 5 6]]\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zcr0VDx66wZr",
        "outputId": "adb2a471-6889-4860-a0da-d363d945aaf4"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[1 2 3]\n",
            " [4 5 6]], shape=(2, 3), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "23I-CWp76vrS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Concatenates tensors along one dimension.\n",
        "# https://www.tensorflow.org/api_docs/python/tf/concat\n",
        "# Imagine you have two pieces of paper. concat lets you glue them together along one edge to make a longer piece of paper.\n",
        "tensor_a = tf.constant([[1, 2], [3, 4]])\n",
        "tensor_b = tf.constant([[5, 6], [7, 8]])\n",
        "concatenated_tensor = tf.concat([tensor_a, tensor_b], axis=0)\n",
        "print(concatenated_tensor)  # Output: [[1 2], [3 4], [5 6], [7 8]]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RBT2xAgG6x6j",
        "outputId": "f4503024-a730-474d-9abd-6232952a175c"
      },
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[1 2]\n",
            " [3 4]\n",
            " [5 6]\n",
            " [7 8]], shape=(4, 2), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# Stacks a list of rank-R tensors into one rank-(R+1) tensor.\n",
        "# https://www.tensorflow.org/api_docs/python/tf/stack\n",
        "# Imagine you have a stack of pancakes. tf.stack lets you combine them into a single, taller stack.\n",
        "tensor_1 = tf.constant([1, 2, 3])\n",
        "tensor_2 = tf.constant([4, 5, 6])\n",
        "stacked_tensor = tf.stack([tensor_1, tensor_2], axis=0)\n",
        "print(stacked_tensor)  # Output: [[1 2 3], [4 5 6]]\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w0rmds1861S-",
        "outputId": "1d88ac36-d527-4ec9-8eda-9faea0b2f4e1"
      },
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[1 2 3]\n",
            " [4 5 6]], shape=(2, 3), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Pads a tensor.\n",
        "# https://www.tensorflow.org/api_docs/python/tf/pad\n",
        "# Imagine you have a picture and you want to add a border around it. tf.pad lets you do this by adding extra pixels (padding) around the edges.\n",
        "tensor = tf.constant([[1, 2], [3, 4]])\n",
        "padded_tensor = tf.pad(tensor, paddings=[[1, 1], [2, 2]])\n",
        "print(padded_tensor)  # Output: [[0 0 0 0 0 0], [0 0 1 2 0 0], [0 0 3 4 0 0], [0 0 0 0 0 0]]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-Gl6l-Y97nus",
        "outputId": "3e1b7717-8235-4a0a-f159-7e9262752deb"
      },
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[0 0 0 0 0 0]\n",
            " [0 0 1 2 0 0]\n",
            " [0 0 3 4 0 0]\n",
            " [0 0 0 0 0 0]], shape=(4, 6), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Gathers slices from params axis axis according to indices.\n",
        "# https://www.tensorflow.org/api_docs/python/tf/gather\n",
        "# Imagine you have a basket of fruits and you want to pick out specific fruits based on their positions in the basket. tf.gather lets you do this.\n",
        "params = tf.constant([['a', 'b'], ['c', 'd'], ['e', 'f']])\n",
        "indices = tf.constant([0, 2])\n",
        "gathered_tensor = tf.gather(params, indices)\n",
        "print(gathered_tensor)  # Output: [['a' 'b'], ['e' 'f']]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Uf4_mtl27ok4",
        "outputId": "23fbd4bb-7952-4f52-8e01-7fe12f002358"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[b'a' b'b']\n",
            " [b'e' b'f']], shape=(2, 2), dtype=string)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ERRTbaM28PKh"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}