Introduction to Tensorflow.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "VSCM1oL8v9oV",
        "iE3x6GZwwtbg",
        "1K7pBOTUKYhB",
        "elE0pHaizWUX",
        "-GAi_v_I5Ga_",
        "T6bczY8fwe4q",
        "b-5QxV8J-KdR"
      ],
      "authorship_tag": "ABX9TyOzYJy5C62Bdedb+9I4r0al",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Anikate-De/TensorFlow-Deep-Learning/blob/main/Introduction_to_Tensorflow.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Tensorflow Basics\n",
        "\n",
        "Table of Contents - \n",
        "\n",
        "\n",
        "*   Creating & Manipulating Tensors\n",
        "*   Tensorflow + Numpy\n",
        "*   Expanding Tensors\n",
        "*   Matrix Multiplication\n",
        "*   One Hot Encoding\n"
      ],
      "metadata": {
        "id": "VSCM1oL8v9oV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Creating and Manipulating Tensors"
      ],
      "metadata": {
        "id": "iE3x6GZwwtbg"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "V-mF9F_Mv4_2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "fc12f0d4-9fb8-4ae6-f332-f81df243ecdf"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2.11.0'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 1
        }
      ],
      "source": [
        "import tensorflow as tf\n",
        "tf.__version__"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "scalar = tf.constant(10)\n",
        "scalar"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4t9KYFySzZzG",
        "outputId": "b9d3132b-33d2-472f-d03d-24a54324f06c"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int32, numpy=10>"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "vector = tf.constant([10,20,30])\n",
        "vector"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5vzRY94HztBR",
        "outputId": "26f698e9-ac30-4c0f-e515-28a0575737ad"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=int32, numpy=array([10, 20, 30], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "vector.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TX_o5H7T18pD",
        "outputId": "06c5957d-f8ba-4cd0-98bf-3937e67046a8"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "matrix = tf.constant([[5,32,5],[14,21,7],[7,2,5]])\n",
        "matrix"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SieD_Mx32BFK",
        "outputId": "f82e2b27-fb25-4d1c-c461-52ca7e304375"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              "array([[ 5, 32,  5],\n",
              "       [14, 21,  7],\n",
              "       [ 7,  2,  5]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "matrix.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x-VWQAYI2O1m",
        "outputId": "e1f4c4da-630e-45db-d536-85be6e19def6"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Mutable Tensors"
      ],
      "metadata": {
        "id": "WoAtZy3K661K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "m_tensor = tf.Variable([12,23,2352,23])\n",
        "m_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uWxUvfpU6508",
        "outputId": "024373a9-61e2-4548-fd44-f196f2648efe"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Variable 'Variable:0' shape=(4,) dtype=int32, numpy=array([  12,   23, 2352,   23], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "m_tensor[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cJ6nNi777Mdm",
        "outputId": "4623848b-20c6-4ae2-d1eb-522e84c6e7a4"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int32, numpy=12>"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "m_tensor[0].assign(9)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IV5nOiFD7h1I",
        "outputId": "02e9cd05-f984-4f79-e652-ffba73a4c0c2"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Variable 'UnreadVariable' shape=(4,) dtype=int32, numpy=array([   9,   23, 2352,   23], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Random Tensors"
      ],
      "metadata": {
        "id": "IQF88KRm-9VD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "gen = tf.random.Generator.from_seed(4)\n",
        "gen.uniform(shape = (3,2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0APjXQ2F-8Wl",
        "outputId": "5aebcc76-ce49-4149-f1e7-d581c6268740"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              "array([[0.48252344, 0.15580535],\n",
              "       [0.3703227 , 0.49210668],\n",
              "       [0.567016  , 0.2077086 ]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "gen = tf.random.Generator.from_seed(4)\n",
        "gen.normal(shape = (3,2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2icnoalZ_Mzu",
        "outputId": "5ba8ee8b-364c-46c5-c09d-1f176d4f4ada"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              "array([[ 1.0019137 ,  0.6735137 ],\n",
              "       [ 0.06987712, -1.4077919 ],\n",
              "       [ 1.0278524 ,  0.27974114]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "gen_nd = tf.random.Generator.from_non_deterministic_state()\n",
        "gen_nd.uniform(shape = (3,2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C8ofVS58AFmS",
        "outputId": "8b5ca78e-ebb2-453a-adc5-0e027bd766be"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              "array([[0.08305824, 0.61589456],\n",
              "       [0.6534134 , 0.4597801 ],\n",
              "       [0.98435974, 0.2061199 ]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "gen_2 = tf.random.Generator.from_seed(4)\n",
        "tf.random.shuffle(gen_2.normal(shape = (3,2)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iqRP2zFyEaAD",
        "outputId": "d74e3e3c-6bb8-4d5d-9835-76f8637ed7f3"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              "array([[ 1.0019137 ,  0.6735137 ],\n",
              "       [ 0.06987712, -1.4077919 ],\n",
              "       [ 1.0278524 ,  0.27974114]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = tf.constant([[10,2,3],[13,14,5],[46,36,1]])\n",
        "\n",
        "tf.random.set_seed(4)\n",
        "shuffled = tf.random.shuffle(tensor, seed =4)\n",
        "\n",
        "tensor, shuffled"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wK1m4bksHr_O",
        "outputId": "1c30faa0-bfe8-4f0d-8cd5-ea8d0a9ea454"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              " array([[10,  2,  3],\n",
              "        [13, 14,  5],\n",
              "        [46, 36,  1]], dtype=int32)>,\n",
              " <tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              " array([[10,  2,  3],\n",
              "        [13, 14,  5],\n",
              "        [46, 36,  1]], dtype=int32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Tensorflow + Numpy"
      ],
      "metadata": {
        "id": "1K7pBOTUKYhB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.zeros((3,2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gTkWg75HKa5k",
        "outputId": "d42615c9-8478-4dca-cad4-bcd96c7838d2"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              "array([[0., 0.],\n",
              "       [0., 0.],\n",
              "       [0., 0.]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.ones((2,2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8mwq0nbgKbUH",
        "outputId": "ce15e720-157e-4e8f-ab77-e3436826d90e"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n",
              "array([[1., 1.],\n",
              "       [1., 1.]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "np_A = np.array([2,3,1])\n",
        "np_A"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i4aVe-RyLlZw",
        "outputId": "b8c3639a-b012-4aa9-e2af-05a6602d804b"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2, 3, 1])"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf_A = tf.constant(np_A)\n",
        "tf_A"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "anYZKMUVLyWB",
        "outputId": "3d412844-fc76-477c-fb95-9a4da1f69163"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=int64, numpy=array([2, 3, 1])>"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**NOTE:** The default dataathpe of NumPy arrays is float64 while that of TensorFlow is float32"
      ],
      "metadata": {
        "id": "p51J_yEczhQA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Expanding Tensors"
      ],
      "metadata": {
        "id": "elE0pHaizWUX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "rank_2_tensor = tf.zeros(shape=(2,3))\n",
        "rank_2_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lmKpfZq5vQL-",
        "outputId": "12ffe07f-81d4-465b-d216-0f9f776bdb5a"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3), dtype=float32, numpy=\n",
              "array([[0., 0., 0.],\n",
              "       [0., 0., 0.]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rank_3_tensor = rank_2_tensor[..., tf.newaxis]\n",
        "rank_3_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qAilinOkzUzz",
        "outputId": "f86703e4-2c17-41aa-a88e-185949174aaf"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3, 1), dtype=float32, numpy=\n",
              "array([[[0.],\n",
              "        [0.],\n",
              "        [0.]],\n",
              "\n",
              "       [[0.],\n",
              "        [0.],\n",
              "        [0.]]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Alternative to `tf.newaxis`\n",
        "Works just like inserting an element to a list, here the list is `tensor.shape`"
      ],
      "metadata": {
        "id": "H65WsesT0LAx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.expand_dims(rank_2_tensor, axis=2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iiSaKeoL0JU6",
        "outputId": "1c845b8a-e248-4a96-9213-3f21c2afb59a"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3, 1), dtype=float32, numpy=\n",
              "array([[[0.],\n",
              "        [0.],\n",
              "        [0.]],\n",
              "\n",
              "       [[0.],\n",
              "        [0.],\n",
              "        [0.]]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Matrix multiplication"
      ],
      "metadata": {
        "id": "-GAi_v_I5Ga_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = tf.constant([[1,2],[3,4]])\n",
        "tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-vMFfwJr5Chf",
        "outputId": "a0033818-2b17-4e20-d807-c65cf33c9da2"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[1, 2],\n",
              "       [3, 4]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor * tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I69ueZ9y5SjV",
        "outputId": "174bf4d9-2738-4c49-faf7-99648cddaa66"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[ 1,  4],\n",
              "       [ 9, 16]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor @ tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a_LvqcX95Xuh",
        "outputId": "d5f93b03-a1cf-4787-fd72-47f43af1d0f1"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[ 7, 10],\n",
              "       [15, 22]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.matmul(tensor, tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hn79qD-05tVL",
        "outputId": "846b5f36-6ac6-4530-9a86-661809866d3f"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[ 7, 10],\n",
              "       [15, 22]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Multiplying matrices of different dimensions."
      ],
      "metadata": {
        "id": "yP33enD8_ULf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = tf.constant([[1,2],[3,4],[5,6]])\n",
        "tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bViH57dd_mCa",
        "outputId": "7e6d44ec-43f3-4d59-b4dc-d7de876a70ba"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              "array([[1, 2],\n",
              "       [3, 4],\n",
              "       [5, 6]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# This should give an error\n",
        "tensor @ tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 347
        },
        "id": "U0qWR8Dw_wrw",
        "outputId": "8ac49955-8791-4832-d8bc-12e89613d7c2"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "error",
          "ename": "InvalidArgumentError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mInvalidArgumentError\u001b[0m                      Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-27-eb81ecae50e4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# This should give an error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtensor\u001b[0m \u001b[0;34m@\u001b[0m \u001b[0mtensor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/util/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    151\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    152\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 153\u001b[0;31m       \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfiltered_tb\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    154\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    155\u001b[0m       \u001b[0;32mdel\u001b[0m \u001b[0mfiltered_tb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/framework/ops.py\u001b[0m in \u001b[0;36mraise_from_not_ok_status\u001b[0;34m(e, name)\u001b[0m\n\u001b[1;32m   7213\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mraise_from_not_ok_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   7214\u001b[0m   \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmessage\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\" name: \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m\"\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 7215\u001b[0;31m   \u001b[0;32mraise\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_status_to_exception\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   7216\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   7217\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mInvalidArgumentError\u001b[0m: {{function_node __wrapped__MatMul_device_/job:localhost/replica:0/task:0/device:CPU:0}} Matrix size-incompatible: In[0]: [3,2], In[1]: [3,2] [Op:MatMul]"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.reshape(tensor, shape=(2,3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Za6IfcI7_z-A",
        "outputId": "5bf9c830-8428-4839-8746-a7ac9a54fc84"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3), dtype=int32, numpy=\n",
              "array([[1, 2, 3],\n",
              "       [4, 5, 6]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor @ tf.reshape(tensor, shape=(2,3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vOcDbC-h_-qc",
        "outputId": "ce28b5ab-1ec9-4aa7-a0bb-6df7084ed9b9"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              "array([[ 9, 12, 15],\n",
              "       [19, 26, 33],\n",
              "       [29, 40, 51]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.transpose(tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1lU6B6vOAG2q",
        "outputId": "7175cb5a-b5b8-4719-ac4c-271ec78ac94c"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3), dtype=int32, numpy=\n",
              "array([[1, 3, 5],\n",
              "       [2, 4, 6]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor @ tf.transpose(tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rbknOfSEAVk1",
        "outputId": "63f292cb-4d87-42e6-a7dd-1b5e417b02b2"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              "array([[ 5, 11, 17],\n",
              "       [11, 25, 39],\n",
              "       [17, 39, 61]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.matmul(tensor, tensor, transpose_b=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZbtO5fLoAcEq",
        "outputId": "a3d313d3-825b-411e-e02e-ef9d542a27df"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              "array([[ 5, 11, 17],\n",
              "       [11, 25, 39],\n",
              "       [17, 39, 61]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Using tensordot()\n",
        "tf.tensordot(tensor, tf.transpose(tensor), axes = 1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SGoJtI_kB6PK",
        "outputId": "57722921-f4ca-407d-cd29-c5399355fc6b"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              "array([[ 5, 11, 17],\n",
              "       [11, 25, 39],\n",
              "       [17, 39, 61]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### One-Hot Encoding"
      ],
      "metadata": {
        "id": "T6bczY8fwe4q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "indices = [2,1,2]\n",
        "tf.one_hot(indices, depth = 3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5ED6QMeUwhi4",
        "outputId": "45b66b40-a5f7-4f00-e3f9-70f3a142c54c"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=float32, numpy=\n",
              "array([[0., 0., 1.],\n",
              "       [0., 1., 0.],\n",
              "       [0., 0., 1.]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "indices = [0,1,2,3,4]\n",
        "tf.one_hot(indices, depth = 5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XH76UdECz5tI",
        "outputId": "d409629a-e937-43b3-c7f1-0a7397d4bcf6"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(5, 5), dtype=float32, numpy=\n",
              "array([[1., 0., 0., 0., 0.],\n",
              "       [0., 1., 0., 0., 0.],\n",
              "       [0., 0., 1., 0., 0.],\n",
              "       [0., 0., 0., 1., 0.],\n",
              "       [0., 0., 0., 0., 1.]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.one_hot(indices, depth = 3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pjiAmPdWz_bj",
        "outputId": "b18d92a4-ffba-44e9-8a40-94fc615724ae"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(5, 3), dtype=float32, numpy=\n",
              "array([[1., 0., 0.],\n",
              "       [0., 1., 0.],\n",
              "       [0., 0., 1.],\n",
              "       [0., 0., 0.],\n",
              "       [0., 0., 0.]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.one_hot(indices, depth = 8)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jY9e6xB90GYz",
        "outputId": "d337c748-527a-45ae-e592-4b836261dd6c"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(5, 8), dtype=float32, numpy=\n",
              "array([[1., 0., 0., 0., 0., 0., 0., 0.],\n",
              "       [0., 1., 0., 0., 0., 0., 0., 0.],\n",
              "       [0., 0., 1., 0., 0., 0., 0., 0.],\n",
              "       [0., 0., 0., 1., 0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0., 1., 0., 0., 0.]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exercises"
      ],
      "metadata": {
        "id": "b-5QxV8J-KdR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "1. Create a vector, scalar, matrix and tensor with values of your choosing using tf.constant().\n",
        "2. Find the shape, rank and size of the tensors you created in 1.\n",
        "3. Create two tensors containing random values between 0 and 1 with shape [5, 300].\n",
        "4. Multiply the two tensors you created in 3 using matrix multiplication.\n",
        "5. Multiply the two tensors you created in 3 using dot product.\n",
        "6. Create a tensor with random values between 0 and 1 with shape [224, 224, 3].\n",
        "7. Find the min and max values of the tensor you created in 6.\n",
        "8. Create a tensor with random values of shape [1, 224, 224, 3] then squeeze it to change the shape to [224, 224, 3].\n",
        "9. Create a tensor with shape [10] using your own choice of values, then find the index which has the maximum value.\n",
        "10. One-hot encode the tensor you created in 9.\n"
      ],
      "metadata": {
        "id": "YZFExKzG-OcG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a vector, scalar, matrix and tensor with values of your choosing using tf.constant()\n",
        "vector = tf.constant([10,9,8])\n",
        "scalar = tf.constant(4)\n",
        "matrix = tf.constant([[10,9],[8,7],[6,5]])\n",
        "tensor = tf.constant([[[1,2],[3,4],[5,6]],[[7,8],[9,10],[11,12]]])\n",
        "print(scalar, vector, matrix, tensor, sep='\\n')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iXJ0rCKS-yFx",
        "outputId": "ecafbe0b-9dfc-4182-aa93-0b4732b5d566"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(4, shape=(), dtype=int32)\n",
            "tf.Tensor([10  9  8], shape=(3,), dtype=int32)\n",
            "tf.Tensor(\n",
            "[[10  9]\n",
            " [ 8  7]\n",
            " [ 6  5]], shape=(3, 2), dtype=int32)\n",
            "tf.Tensor(\n",
            "[[[ 1  2]\n",
            "  [ 3  4]\n",
            "  [ 5  6]]\n",
            "\n",
            " [[ 7  8]\n",
            "  [ 9 10]\n",
            "  [11 12]]], shape=(2, 3, 2), dtype=int32)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the shape, rank and size of the tensors you created in 1.\n",
        "scalar.shape, scalar.ndim, tf.size(scalar)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ljQC5p8__6pT",
        "outputId": "8645ec03-06a2-457f-a13f-da3607408fe8"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorShape([]), 0, <tf.Tensor: shape=(), dtype=int32, numpy=1>)"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "vector.shape, vector.ndim, tf.size(vector)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a3V8ViI0AbEx",
        "outputId": "0e53e1d6-1f3e-48a3-f37d-62826be0860a"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorShape([3]), 1, <tf.Tensor: shape=(), dtype=int32, numpy=3>)"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "matrix.shape, matrix.ndim, tf.size(matrix)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vbodvrQkAg7v",
        "outputId": "4a5539a9-f33d-4350-832d-2c0edb00089e"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorShape([3, 2]), 2, <tf.Tensor: shape=(), dtype=int32, numpy=6>)"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor.shape, tensor.ndim, tf.size(tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JZqlC8EmAjlh",
        "outputId": "d6219938-1c55-4bc9-fc58-ae5e65dab7ef"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorShape([2, 3, 2]), 3, <tf.Tensor: shape=(), dtype=int32, numpy=12>)"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create two tensors containing random values between 0 and 1 with shape [5, 300]\n",
        "generator = tf.random.Generator.from_seed(4)\n",
        "A = generator.uniform(shape = [5,300], maxval = 1)\n",
        "B = generator.uniform(shape = [5,300], maxval = 1)\n",
        "A, B"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oNGnc5UvAmc_",
        "outputId": "9cd7cefc-5c66-4949-9e0f-bedba1b944f0"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(5, 300), dtype=float32, numpy=\n",
              " array([[0.48252344, 0.15580535, 0.3703227 , ..., 0.6030959 , 0.5261806 ,\n",
              "         0.29263592],\n",
              "        [0.36828172, 0.9125351 , 0.9311757 , ..., 0.28039837, 0.23856235,\n",
              "         0.0295794 ],\n",
              "        [0.49198222, 0.6657673 , 0.8861321 , ..., 0.9389367 , 0.6189861 ,\n",
              "         0.09308314],\n",
              "        [0.67127347, 0.554566  , 0.41143024, ..., 0.9333025 , 0.5141679 ,\n",
              "         0.6085166 ],\n",
              "        [0.9822712 , 0.155164  , 0.21270347, ..., 0.54543686, 0.32094967,\n",
              "         0.6671035 ]], dtype=float32)>,\n",
              " <tf.Tensor: shape=(5, 300), dtype=float32, numpy=\n",
              " array([[0.98478794, 0.59075475, 0.94479775, ..., 0.5115601 , 0.19735217,\n",
              "         0.38531756],\n",
              "        [0.5596421 , 0.81612885, 0.04916477, ..., 0.41156566, 0.97969055,\n",
              "         0.2477696 ],\n",
              "        [0.478989  , 0.29646766, 0.6018213 , ..., 0.46831   , 0.8992487 ,\n",
              "         0.7710763 ],\n",
              "        [0.7299831 , 0.569106  , 0.7414402 , ..., 0.8913442 , 0.9727906 ,\n",
              "         0.0993737 ],\n",
              "        [0.9272233 , 0.31778145, 0.2729888 , ..., 0.5485951 , 0.00564456,\n",
              "         0.63936794]], dtype=float32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiply the two tensors you created in 3 using matrix multiplication\n",
        "A_BT = tf.matmul(A, B, transpose_b = True)\n",
        "AT_B = tf.matmul(A, B, transpose_a = True)\n",
        "A_BT, AT_B"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u-RmLD0YBpjP",
        "outputId": "76b9c957-e0a2-4b04-b1fc-bbe0986fc3db"
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(5, 5), dtype=float32, numpy=\n",
              " array([[75.55132 , 74.365746, 76.039635, 76.38896 , 73.098564],\n",
              "        [78.32044 , 74.37536 , 74.61407 , 76.59617 , 73.49047 ],\n",
              "        [74.78546 , 73.561714, 71.09874 , 75.65093 , 72.07529 ],\n",
              "        [71.47365 , 68.48248 , 68.918884, 72.4144  , 68.58531 ],\n",
              "        [77.21607 , 73.47504 , 74.361496, 74.025116, 73.40432 ]],\n",
              "       dtype=float32)>, <tf.Tensor: shape=(300, 300), dtype=float32, numpy=\n",
              " array([[2.3177464 , 1.4256486 , 1.5359371 , ..., 1.7660168 , 1.5569967 ,\n",
              "         1.3512692 ],\n",
              "        [1.531719  , 1.3990825 , 1.0462776 , ..., 1.3464888 , 2.0637934 ,\n",
              "         0.9538065 ],\n",
              "        [1.8078227 , 1.5431794 , 1.2920709 , ..., 1.4710809 , 2.1836374 ,\n",
              "         1.2335654 ],\n",
              "        ...,\n",
              "        [2.3876214 , 1.567965  , 1.9895476 , ..., 1.9947534 , 2.1490502 ,\n",
              "         1.4673301 ],\n",
              "        [1.6210994 , 1.0836586 , 1.3502225 , ..., 1.2916064 , 1.396172  ,\n",
              "         0.99544036],\n",
              "        [1.4120848 , 0.7829163 , 0.9672459 , ..., 1.1138339 , 0.7661606 ,\n",
              "         0.67885596]], dtype=float32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiply the two tensors you created in 3 using dot product.\n",
        "tf.tensordot(A, tf.transpose(B), axes = 1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m1RxYMYKCLLe",
        "outputId": "dec862d1-b5c7-40e0-dbb6-3b58be5b538b"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(5, 5), dtype=float32, numpy=\n",
              "array([[75.55133 , 74.365746, 76.03965 , 76.38897 , 73.09859 ],\n",
              "       [78.32044 , 74.37536 , 74.61405 , 76.59618 , 73.49047 ],\n",
              "       [74.78547 , 73.5617  , 71.09874 , 75.65094 , 72.07527 ],\n",
              "       [71.47365 , 68.48249 , 68.918884, 72.414406, 68.58531 ],\n",
              "       [77.21606 , 73.47503 , 74.36149 , 74.025116, 73.40433 ]],\n",
              "      dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensor with random values between 0 and 1 with shape [224, 224, 3]\n",
        "R = generator.uniform(shape = [224, 224, 3], maxval = 1)\n",
        "R"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NhaoeuWKCUQP",
        "outputId": "ce2a5821-26ee-48b1-cb75-9d1c2a5f9d15"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(224, 224, 3), dtype=float32, numpy=\n",
              "array([[[0.06055391, 0.20765138, 0.39415145],\n",
              "        [0.88959014, 0.58133674, 0.7304603 ],\n",
              "        [0.4234984 , 0.70738983, 0.69285405],\n",
              "        ...,\n",
              "        [0.13194835, 0.9543567 , 0.36554527],\n",
              "        [0.46473908, 0.37070096, 0.20172966],\n",
              "        [0.9464748 , 0.41708136, 0.47961164]],\n",
              "\n",
              "       [[0.46503544, 0.13552952, 0.6256918 ],\n",
              "        [0.70894873, 0.79171   , 0.29167414],\n",
              "        [0.3747114 , 0.59163976, 0.27431762],\n",
              "        ...,\n",
              "        [0.8800162 , 0.9663782 , 0.6629566 ],\n",
              "        [0.65770805, 0.8434397 , 0.14218843],\n",
              "        [0.6889287 , 0.8501986 , 0.92880225]],\n",
              "\n",
              "       [[0.02502942, 0.4491155 , 0.9136689 ],\n",
              "        [0.47701693, 0.83316267, 0.18190026],\n",
              "        [0.9994818 , 0.4328984 , 0.8799443 ],\n",
              "        ...,\n",
              "        [0.8437983 , 0.8072525 , 0.9813819 ],\n",
              "        [0.51142156, 0.6302892 , 0.20099247],\n",
              "        [0.678445  , 0.20886219, 0.13179481]],\n",
              "\n",
              "       ...,\n",
              "\n",
              "       [[0.24661326, 0.07503164, 0.21540868],\n",
              "        [0.21928763, 0.25246143, 0.00696731],\n",
              "        [0.20501924, 0.8414223 , 0.32215953],\n",
              "        ...,\n",
              "        [0.6637447 , 0.6738875 , 0.5277499 ],\n",
              "        [0.94171953, 0.91274345, 0.5333245 ],\n",
              "        [0.98630285, 0.5565568 , 0.8982018 ]],\n",
              "\n",
              "       [[0.791962  , 0.83507025, 0.826923  ],\n",
              "        [0.92190015, 0.753626  , 0.8926562 ],\n",
              "        [0.61060953, 0.3960395 , 0.0228045 ],\n",
              "        ...,\n",
              "        [0.8566772 , 0.82848656, 0.9667237 ],\n",
              "        [0.9170002 , 0.7322024 , 0.4686545 ],\n",
              "        [0.2903992 , 0.63116896, 0.14775813]],\n",
              "\n",
              "       [[0.40202534, 0.09286594, 0.63395286],\n",
              "        [0.41461384, 0.4671055 , 0.36488974],\n",
              "        [0.26873887, 0.84929   , 0.6604215 ],\n",
              "        ...,\n",
              "        [0.02758443, 0.9881369 , 0.12100685],\n",
              "        [0.65333235, 0.19570541, 0.7637863 ],\n",
              "        [0.8010597 , 0.07127059, 0.8623332 ]]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the min and max values of the tensor you created in 6.\n",
        "tf.reduce_min(R).numpy(), tf.reduce_max(R).numpy()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tZ8J_B8uCeXy",
        "outputId": "1d381282-cf73-43f4-aae6-db32c8bc0892"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2.861023e-06, 0.9999894)"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensor with random values of shape [1, 224, 224, 3] then squeeze it to change the shape to [224, 224, 3].\n",
        "X_expanded = generator.uniform(maxval = 1, shape = [1, 224, 224, 3])\n",
        "X = tf.squeeze(X_expanded)\n",
        "X_expanded, X"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1AAXzLZ7Cz1u",
        "outputId": "000af87a-3f68-456b-b0ec-5027b6740b53"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(1, 224, 224, 3), dtype=float32, numpy=\n",
              " array([[[[0.08117831, 0.81527174, 0.28746533],\n",
              "          [0.8846065 , 0.96122515, 0.5228605 ],\n",
              "          [0.7206248 , 0.16867936, 0.71110976],\n",
              "          ...,\n",
              "          [0.53833485, 0.02839375, 0.6602771 ],\n",
              "          [0.05669451, 0.9795083 , 0.12071812],\n",
              "          [0.10473025, 0.3303094 , 0.55010843]],\n",
              " \n",
              "         [[0.02941966, 0.7347597 , 0.2454226 ],\n",
              "          [0.26676595, 0.11856067, 0.6541959 ],\n",
              "          [0.32202137, 0.25296986, 0.44977129],\n",
              "          ...,\n",
              "          [0.7455926 , 0.47627652, 0.31705928],\n",
              "          [0.61813235, 0.9563526 , 0.5575528 ],\n",
              "          [0.93498456, 0.1042856 , 0.34267318]],\n",
              " \n",
              "         [[0.2934518 , 0.21182227, 0.5480555 ],\n",
              "          [0.9061264 , 0.14498758, 0.77594376],\n",
              "          [0.13320243, 0.3665793 , 0.06977117],\n",
              "          ...,\n",
              "          [0.8568398 , 0.15003228, 0.15453744],\n",
              "          [0.8903086 , 0.48498988, 0.20910311],\n",
              "          [0.4701903 , 0.27314508, 0.68726397]],\n",
              " \n",
              "         ...,\n",
              " \n",
              "         [[0.161744  , 0.3147483 , 0.31733084],\n",
              "          [0.28667486, 0.25969827, 0.24914002],\n",
              "          [0.08129621, 0.9939846 , 0.13771689],\n",
              "          ...,\n",
              "          [0.3678862 , 0.71576166, 0.04848003],\n",
              "          [0.71076787, 0.7694131 , 0.03081572],\n",
              "          [0.77175105, 0.16794884, 0.06651092]],\n",
              " \n",
              "         [[0.3255576 , 0.47651458, 0.37527418],\n",
              "          [0.84305656, 0.78403246, 0.7045311 ],\n",
              "          [0.4247024 , 0.698429  , 0.52813363],\n",
              "          ...,\n",
              "          [0.9423413 , 0.20800483, 0.94587827],\n",
              "          [0.06802797, 0.14151466, 0.8010442 ],\n",
              "          [0.9869772 , 0.09527493, 0.37238395]],\n",
              " \n",
              "         [[0.8625388 , 0.01361525, 0.07969868],\n",
              "          [0.02522981, 0.37776375, 0.38978016],\n",
              "          [0.3024596 , 0.6265663 , 0.11788166],\n",
              "          ...,\n",
              "          [0.3013345 , 0.70225585, 0.82739663],\n",
              "          [0.87349653, 0.70981455, 0.71487737],\n",
              "          [0.07662225, 0.95884824, 0.5550399 ]]]], dtype=float32)>,\n",
              " <tf.Tensor: shape=(224, 224, 3), dtype=float32, numpy=\n",
              " array([[[0.08117831, 0.81527174, 0.28746533],\n",
              "         [0.8846065 , 0.96122515, 0.5228605 ],\n",
              "         [0.7206248 , 0.16867936, 0.71110976],\n",
              "         ...,\n",
              "         [0.53833485, 0.02839375, 0.6602771 ],\n",
              "         [0.05669451, 0.9795083 , 0.12071812],\n",
              "         [0.10473025, 0.3303094 , 0.55010843]],\n",
              " \n",
              "        [[0.02941966, 0.7347597 , 0.2454226 ],\n",
              "         [0.26676595, 0.11856067, 0.6541959 ],\n",
              "         [0.32202137, 0.25296986, 0.44977129],\n",
              "         ...,\n",
              "         [0.7455926 , 0.47627652, 0.31705928],\n",
              "         [0.61813235, 0.9563526 , 0.5575528 ],\n",
              "         [0.93498456, 0.1042856 , 0.34267318]],\n",
              " \n",
              "        [[0.2934518 , 0.21182227, 0.5480555 ],\n",
              "         [0.9061264 , 0.14498758, 0.77594376],\n",
              "         [0.13320243, 0.3665793 , 0.06977117],\n",
              "         ...,\n",
              "         [0.8568398 , 0.15003228, 0.15453744],\n",
              "         [0.8903086 , 0.48498988, 0.20910311],\n",
              "         [0.4701903 , 0.27314508, 0.68726397]],\n",
              " \n",
              "        ...,\n",
              " \n",
              "        [[0.161744  , 0.3147483 , 0.31733084],\n",
              "         [0.28667486, 0.25969827, 0.24914002],\n",
              "         [0.08129621, 0.9939846 , 0.13771689],\n",
              "         ...,\n",
              "         [0.3678862 , 0.71576166, 0.04848003],\n",
              "         [0.71076787, 0.7694131 , 0.03081572],\n",
              "         [0.77175105, 0.16794884, 0.06651092]],\n",
              " \n",
              "        [[0.3255576 , 0.47651458, 0.37527418],\n",
              "         [0.84305656, 0.78403246, 0.7045311 ],\n",
              "         [0.4247024 , 0.698429  , 0.52813363],\n",
              "         ...,\n",
              "         [0.9423413 , 0.20800483, 0.94587827],\n",
              "         [0.06802797, 0.14151466, 0.8010442 ],\n",
              "         [0.9869772 , 0.09527493, 0.37238395]],\n",
              " \n",
              "        [[0.8625388 , 0.01361525, 0.07969868],\n",
              "         [0.02522981, 0.37776375, 0.38978016],\n",
              "         [0.3024596 , 0.6265663 , 0.11788166],\n",
              "         ...,\n",
              "         [0.3013345 , 0.70225585, 0.82739663],\n",
              "         [0.87349653, 0.70981455, 0.71487737],\n",
              "         [0.07662225, 0.95884824, 0.5550399 ]]], dtype=float32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensor with shape [10] using your own choice of values, then find the index which has the maximum value.\n",
        "\n",
        "tensor = tf.constant([1,23,41,21,5,12,15,25,346,0])\n",
        "\n",
        "tf.argmax(tensor).numpy()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZVrej49HC6cG",
        "outputId": "5c5c4592-d905-448d-ecca-7a39a250b649"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# One-hot encode the tensor you created in 9.\n",
        "tf.one_hot(tensor, depth = 10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RHdx82l0C8Z4",
        "outputId": "eb4133aa-e601-4316-8e60-396dd4356bc8"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(10, 10), dtype=float32, numpy=\n",
              "array([[0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
              "       [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Extra Curriculum"
      ],
      "metadata": {
        "id": "W2t1GMG5FNWR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Try to create a series of tensor functions to calculate your most recent grocery bill (it's okay if you don't use the names of the items, just the price in numerical form).\n",
        "\n",
        "How would you calculate your grocery bill for the month and for the year using tensors?"
      ],
      "metadata": {
        "id": "cVhyWJM2FVlJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "First, we create a tensor to store all the input data\n",
        "\n",
        "The input data is structured in the following way -\n",
        "\n",
        "[[cost_of_item, no_of_items_bought],\n",
        " [100, 3]]\n",
        "'''\n",
        "\n",
        "bill = tf.constant([[9.99, 4],\n",
        "                    [13.50, 1],\n",
        "                    [49.99, 1],\n",
        "                    [0.87, 6],\n",
        "                    [4.99, 1],\n",
        "                    [3.25, 3],\n",
        "                    [2.00, 1],\n",
        "                    [18.99, 4],\n",
        "                    [7.00, 2],\n",
        "                    [0.50, 2],\n",
        "                    [8.50, 3]])\n",
        "\n",
        "bill"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L19NjL81FQfo",
        "outputId": "77fdcaf0-19c1-4254-a0e7-221f8d4529c7"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(11, 2), dtype=float32, numpy=\n",
              "array([[ 9.99,  4.  ],\n",
              "       [13.5 ,  1.  ],\n",
              "       [49.99,  1.  ],\n",
              "       [ 0.87,  6.  ],\n",
              "       [ 4.99,  1.  ],\n",
              "       [ 3.25,  3.  ],\n",
              "       [ 2.  ,  1.  ],\n",
              "       [18.99,  4.  ],\n",
              "       [ 7.  ,  2.  ],\n",
              "       [ 0.5 ,  2.  ],\n",
              "       [ 8.5 ,  3.  ]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "We then extract the cost prices of items, and the corressponding number of items purchased into two separate tensors\n",
        "\n",
        "So now, cost of items will be present in a vector (a list)\n",
        "Same applies to the number of items purchased\n",
        "'''\n",
        "\n",
        "prices = bill[:, 0]\n",
        "# Squeeze Prices to get rid of empty dimension\n",
        "prices = tf.squeeze(prices)\n",
        "\n",
        "items = bill[:, -1]\n",
        "# Squeeze Prices to get rid of empty dimension\n",
        "items = tf.squeeze(items)\n",
        "\n",
        "prices, items"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0llOOKI8G7NR",
        "outputId": "a0c495ca-a4b1-47b9-bdaa-c010a7f2fc73"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(11,), dtype=float32, numpy=\n",
              " array([ 9.99, 13.5 , 49.99,  0.87,  4.99,  3.25,  2.  , 18.99,  7.  ,\n",
              "         0.5 ,  8.5 ], dtype=float32)>,\n",
              " <tf.Tensor: shape=(11,), dtype=float32, numpy=array([4., 1., 1., 6., 1., 3., 1., 4., 2., 2., 3.], dtype=float32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "We now multiply the two tensors prices & items together using element-wise multiplication\n",
        "'''\n",
        "\n",
        "expenses = prices * items\n",
        "\n",
        "expenses"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ajWptYPbH-xf",
        "outputId": "6029685d-1b3f-4d5f-aaf6-e92b45edfa56"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(11,), dtype=float32, numpy=\n",
              "array([39.96     , 13.5      , 49.99     ,  5.2200003,  4.99     ,\n",
              "        9.75     ,  2.       , 75.96     , 14.       ,  1.       ,\n",
              "       25.5      ], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "We finally get the sum of all the values present in the expenses tensor\n",
        "'''\n",
        "\n",
        "total_expense = tf.reduce_sum(expenses)\n",
        "\n",
        "total_expense.numpy()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xt7c-NJOId7f",
        "outputId": "e9df6d2a-ca57-4481-fa70-fa20d9691b6a"
      },
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "241.87"
            ]
          },
          "metadata": {},
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the value in a fancier way\n",
        "\n",
        "print('The total expense from the monthly grocery bill input is,', total_expense.numpy())\n",
        "\n",
        "# Get the ceiling value of the expense\n",
        "\n",
        "from math import ceil\n",
        "print('The total payable is,', ceil(total_expense.numpy()))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "63WcahKUIshc",
        "outputId": "22b53f16-276a-4dc5-b74a-b9892ecefd92"
      },
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The total expense from the monthly grocery bill input is, 241.87\n",
            "The total payable is, 242\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "The expense incurred for the year is 12 times the expense in the month\n",
        "'''\n",
        "\n",
        "print('The yearly expense from this particular monthly bill is,', ceil(total_expense.numpy() * 12))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HQxAeKzsI3tG",
        "outputId": "f554a1a3-2d38-4293-e0aa-03197da26a77"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The yearly expense from this particular monthly bill is, 2903\n"
          ]
        }
      ]
    }
  ]
}