00_TF_Developer_Certificate_Course.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RvLcRKntlLS6"
   },
   "source": [
    "## Introduction to Tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "hQikclGllO-i"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 'helper_functions.py' already exists, skipping download.\n",
      "2.13.0\n",
      "1 Physical GPUs, 1 Logical GPUs\n",
      "INFO:tensorflow:Mixed precision compatibility check (mixed_float16): OK\n",
      "Your GPU will likely run quickly with dtype policy mixed_float16 as it has compute capability of at least 7.0. Your GPU: NVIDIA GeForce RTX 3050 Laptop GPU, compute capability 8.6\n",
      "<Policy \"mixed_float16\">\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'\n",
    "os.environ[\"KMP_DUPLICATE_LIB_OK\"]=\"TRUE\"\n",
    "import tensorflow as tf\n",
    "if not os.path.exists(\"helper_functions.py\"):\n",
    "  !wget https://github.com/raw/mrdbourke/tensorflow-deep-learning/main/extras/helper_functions.py\n",
    "else:\n",
    "  print(\"[INFO] 'helper_functions.py' already exists, skipping download.\")\n",
    "from helper_functions import *\n",
    "# from tensorflow.keras import mixed_precision\n",
    "# mixed_precision.set_global_policy('mixed_float16')\n",
    "importTensorflow(memory=4000, precision=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "Uazh_wchlf_7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(), dtype=int32, numpy=7>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create tensors\n",
    "scalar = tf.constant(7)\n",
    "scalar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "dwQIZjwDlzcK"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check the number of dimensions(use ndim for number of divisions)\n",
    "scalar.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "wnqXezV4mS-W"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, <tf.Tensor: shape=(2,), dtype=int32, numpy=array([10, 10], dtype=int32)>)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#create a vector\n",
    "vector = tf.constant([10,10])\n",
    "vector.ndim,vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "KGNBjbXjmXvt"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       " array([[10,  7],\n",
       "        [ 7, 10]], dtype=int32)>,\n",
       " 2)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a matrix\n",
    "matrix = tf.constant([[10,7],[7,10]])\n",
    "matrix,matrix.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "7HYIV9YBn_Ev"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(3, 2), dtype=float16, numpy=\n",
       " array([[10.,  7.],\n",
       "        [ 3.,  4.],\n",
       "        [ 6.,  9.]], dtype=float16)>,\n",
       " 2)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#another matrix\n",
    "another_matrix=tf.constant([[10.,7.],[3.,4.],[6.,9.]],dtype=tf.float16)\n",
    "another_matrix,another_matrix.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "HoMUKDAwokOZ"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(3, 2, 3), dtype=int32, numpy=\n",
       " array([[[ 1,  2,  3],\n",
       "         [ 4,  5,  6]],\n",
       " \n",
       "        [[ 7,  8,  9],\n",
       "         [10, 11, 12]],\n",
       " \n",
       "        [[13, 14, 15],\n",
       "         [16, 17, 18]]], dtype=int32)>,\n",
       " 3)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#increasing the number of dimensions\n",
    "tensor=tf.constant([[[1,2,3],[4,5,6]],\n",
    "                    [[7,8,9],[10,11,12]],\n",
    "                    [[13,14,15],[16,17,18]]],dtype=tf.int32)\n",
    "tensor,tensor.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tB135b9_qDHq"
   },
   "source": [
    "1. Scalar is single number\n",
    "2. Vector is a number with direction\n",
    "3. Matrix is 2-d array of numbers\n",
    "4. Tensor is an n-D array of numbers(where n can be a 0D[scalar] or 1D[Vector])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cBf3DI3swO5y"
   },
   "source": [
    "## Creating tensor with tf.Variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "S_csx0KHqW1A"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Variable 'Variable:0' shape=(2,) dtype=float32, numpy=array([10.,  7.], dtype=float32)>,\n",
       " <tf.Tensor: shape=(2,), dtype=float32, numpy=array([10.,  7.], dtype=float32)>)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# variable\n",
    "changeable_tensor=tf.Variable([10,7],dtype=tf.float32)\n",
    "unchangeable_tensor=tf.constant([10,7],dtype=tf.float32)\n",
    "changeable_tensor,unchangeable_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# changeable_tensor[0] = 12\n",
    "# changeable_tensor\n",
    "\n",
    "\n",
    "# ---------------------------------------------------------------------------\n",
    "# TypeError                                 Traceback (most recent call last)\n",
    "# Cell In[85], line 1\n",
    "# ----> 1 changeable_tensor[0] = 12\n",
    "#       2 changeable_tensor\n",
    "\n",
    "# TypeError: 'ResourceVariable' object does not support item assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "pLlx6JVCxEGc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'UnreadVariable' shape=(2,) dtype=float32, numpy=array([10.,  9.], dtype=float32)>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#changing one of the elements in our changeable_tensor\n",
    "changeable_tensor.assign([10,9])\n",
    "#unchangeable_tensor[0].assign([10])\n",
    "#print(unchangeable_tensor)\n",
    "#therefore cannot change a constant tensor because it is constant\n",
    "\n",
    "\n",
    "#AttributeError: 'tensorflow.python.framework.ops.EagerTensor' object has no attribute 'assign'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ab4-Qee2yYbR"
   },
   "source": [
    "# Random tensors\n",
    "tesnors with random size and random numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "5eLu_Os3yelA"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       " array([[-1.3240396 ,  0.2878567 ],\n",
       "        [-0.87579006, -0.08857017],\n",
       "        [ 0.69211644,  0.84215707]], dtype=float32)>,\n",
       " <tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       " array([[-1.3240396 ,  0.2878567 ],\n",
       "        [-0.87579006, -0.08857017],\n",
       "        [ 0.69211644,  0.84215707]], dtype=float32)>,\n",
       " <tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
       " array([[ True,  True],\n",
       "        [ True,  True],\n",
       "        [ True,  True]])>)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create two random(but equal) tensors\n",
    "random_1=tf.random.Generator.from_seed(7) #set seed for reproducibility\n",
    "random_1=random_1.normal(shape=(3,2))\n",
    "\n",
    "random_2=tf.random.Generator.from_seed(7)\n",
    "random_2=random_2.normal(shape=(3,2))\n",
    "\n",
    "random_1,random_2\n",
    "\n",
    "#are those two equal?\n",
    "random_1,random_2,random_1==random_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "03Rx2fTK1l5U"
   },
   "source": [
    "### shuffle the order of elements in the tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "9Pn6Un081oZw"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[10.,  7.],\n",
       "       [ 6.,  9.],\n",
       "       [ 3.,  4.]], dtype=float32)>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# shuffle a tensor(useful when we need to shuffle our data so that the original order doesnt affect the learning)\n",
    "not_shuffled=tf.constant([[10,7],\n",
    "                          [3,4],\n",
    "                          [6,9]],dtype=tf.float32)\n",
    "# shuffling now\n",
    "tf.random.set_seed(4)\n",
    "tf.random.shuffle(not_shuffled,seed=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Hh-bAAeGFFr-"
   },
   "source": [
    "### Other ways to make tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "fXu2SU2yEhy2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(10, 7), dtype=float32, numpy=\n",
       " array([[1., 1., 1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1., 1., 1., 1.]], dtype=float32)>,\n",
       " <tf.Tensor: shape=(10, 7), dtype=float32, numpy=\n",
       " array([[0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0., 0., 0., 0.]], dtype=float32)>)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a tensor of all ones and zeroes\n",
    "tf.ones([10,7]),tf.zeros([10,7])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "ZxY8UPAZFpId"
   },
   "source": [
    "## You can also turn numpy arrays into tensorflow tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "8lLXWHvTFfpK"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 3, 4), dtype=int32, numpy=\n",
       "array([[[ 1,  2,  3,  4],\n",
       "        [ 5,  6,  7,  8],\n",
       "        [ 9, 10, 11, 12]],\n",
       "\n",
       "       [[13, 14, 15, 16],\n",
       "        [17, 18, 19, 20],\n",
       "        [21, 22, 23, 24]]], dtype=int32)>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#You can also turn numpy arrays into tensorflow tensors\n",
    "import numpy as np\n",
    "np_A=np.arange(1,25,dtype=np.int32)\n",
    "print(np_A)\n",
    "A=tf.constant(np_A,shape=(2,3,4))\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yxFsVe4enw_R"
   },
   "source": [
    "### Getting informaation from tensors\n",
    "1. Shape\n",
    "2. Rank\n",
    "3. Axis/dimension\n",
    "4. Size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "DgoXhA_bGXb5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 3, 4, 5), dtype=int32, numpy=\n",
       "array([[[[0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0]],\n",
       "\n",
       "        [[0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0]],\n",
       "\n",
       "        [[0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0]]],\n",
       "\n",
       "\n",
       "       [[[0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0]],\n",
       "\n",
       "        [[0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0]],\n",
       "\n",
       "        [[0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0]]]], dtype=int32)>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Create a rank 4 tensor\n",
    "rank_4_tensor=tf.zeros([2,3,4,5],dtype=tf.int32)\n",
    "rank_4_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "EUpXreLyp3cK"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([2, 3, 4, 5])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank_4_tensor.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "WKTWq1ipocUj"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(3, 4, 5), dtype=int32, numpy=\n",
       " array([[[0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0]],\n",
       " \n",
       "        [[0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0]],\n",
       " \n",
       "        [[0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0],\n",
       "         [0, 0, 0, 0, 0]]], dtype=int32)>,\n",
       " TensorShape([2, 3, 4, 5]),\n",
       " 4,\n",
       " <tf.Tensor: shape=(), dtype=int32, numpy=120>)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank_4_tensor[0],rank_4_tensor.shape,rank_4_tensor.ndim,tf.size(rank_4_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "CYMbt5zKpZ5i"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datatype of every element:  <dtype: 'int32'>\n",
      "Number of dimensions(rank):  4\n",
      "Shape of tensor:  (2, 3, 4, 5)\n",
      "Elements along the 0 axis:  2\n",
      "Elements along the last axis:  5\n",
      "Total number of elements in tensor:  120\n"
     ]
    }
   ],
   "source": [
    "#Get various attributes of tensors\n",
    "print(\"Datatype of every element: \",rank_4_tensor.dtype)\n",
    "print(\"Number of dimensions(rank): \",rank_4_tensor.ndim)\n",
    "print(\"Shape of tensor: \",rank_4_tensor.shape)\n",
    "print(\"Elements along the 0 axis: \",rank_4_tensor.shape[0])\n",
    "print(\"Elements along the last axis: \",rank_4_tensor.shape[-1])\n",
    "print(\"Total number of elements in tensor: \",tf.size(rank_4_tensor).numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "apZPt1VwrUgD"
   },
   "source": [
    "### Indexing tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "NTPA_S41qBno"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2, 2, 2), dtype=int32, numpy=\n",
       "array([[[[0, 0],\n",
       "         [0, 0]],\n",
       "\n",
       "        [[0, 0],\n",
       "         [0, 0]]],\n",
       "\n",
       "\n",
       "       [[[0, 0],\n",
       "         [0, 0]],\n",
       "\n",
       "        [[0, 0],\n",
       "         [0, 0]]]], dtype=int32)>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the first two elements of each dimesnions\n",
    "rank_4_tensor[:2,:2,:2,:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "9pfi105VsQDT"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(1, 1, 1, 5), dtype=int32, numpy=array([[[[0, 0, 0, 0, 0]]]], dtype=int32)>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Get the first element from each dimension from each index except from the final one\n",
    "rank_4_tensor[:1,:1,:1,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "ayzf6YzhtlH0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       " array([[10,  7],\n",
       "        [ 6,  9]], dtype=int32)>,\n",
       " 2,\n",
       " TensorShape([2, 2]),\n",
       " 4)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a rank 2 dimensions\n",
    "rank_2_tensor=tf.constant([[10,7],[6,9]],dtype=tf.int32)\n",
    "rank_2_tensor,rank_2_tensor.ndim,rank_2_tensor.shape,tf.size(rank_2_tensor).numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "-Xiiwk7YumZJ"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 9], dtype=int32)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Get last element of each row\n",
    "rank_2_tensor[:,-1].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "Cis92i_6us_F"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2, 1), dtype=int32, numpy=\n",
       "array([[[10],\n",
       "        [ 7]],\n",
       "\n",
       "       [[ 6],\n",
       "        [ 9]]], dtype=int32)>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Adding extra dimesnion\n",
    "rank_3_tensor=rank_2_tensor[...,tf.newaxis]\n",
    "rank_3_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "2eOz5c6DvgjR"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2, 1), dtype=int32, numpy=\n",
       "array([[[10],\n",
       "        [ 7]],\n",
       "\n",
       "       [[ 6],\n",
       "        [ 9]]], dtype=int32)>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_understand=tf.constant([[10,7],[6,9]],dtype=tf.int32)\n",
    "change_example=example_understand[:,:,tf.newaxis]\n",
    "change_example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "6sR2hTLsv4pu"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2, 1), dtype=int32, numpy=\n",
       "array([[[10],\n",
       "        [ 7]],\n",
       "\n",
       "       [[ 6],\n",
       "        [ 9]]], dtype=int32)>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Alternative to tf.new axis\n",
    "tf.expand_dims(rank_2_tensor,axis=-1)   #axis->give the index where to expands"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "4bilzukLwG-Y"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(1, 2, 2), dtype=int32, numpy=\n",
       "array([[[10,  7],\n",
       "        [ 6,  9]]], dtype=int32)>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Expand the 0 axis:\n",
    "tf.expand_dims(rank_2_tensor,axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gEVv4vBCwhnB"
   },
   "source": [
    "### Manipulating tensors (tensor operations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "gR5tikvOwknl"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       " array([[20, 17],\n",
       "        [13, 14]], dtype=int32)>,\n",
       " <tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       " array([[ 0, -3],\n",
       "        [-7, -6]], dtype=int32)>,\n",
       " <tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       " array([[100,  70],\n",
       "        [ 30,  40]], dtype=int32)>,\n",
       " <tf.Tensor: shape=(2, 2), dtype=float64, numpy=\n",
       " array([[1. , 0.7],\n",
       "        [0.3, 0.4]])>)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Basic operations\n",
    "tensor = tf.constant([[10,7],[3,4]])\n",
    "tensor+10,tensor-10,tensor*10,tensor/10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "vLuxx21YxaRa"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       " array([[20, 17],\n",
       "        [13, 14]], dtype=int32)>,\n",
       " <tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       " array([[ 0, -3],\n",
       "        [-7, -6]], dtype=int32)>,\n",
       " <tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       " array([[100,  70],\n",
       "        [ 30,  40]], dtype=int32)>,\n",
       " <tf.Tensor: shape=(2, 2), dtype=float64, numpy=\n",
       " array([[1. , 0.7],\n",
       "        [0.3, 0.4]])>)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using tensorflow built-in functions too\n",
    "# Faster execution when functions are used\n",
    "tf.add(tensor,10),tf.subtract(tensor,10),tf.multiply(tensor,10),tf.divide(tensor,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a4YLE9sxyDvw"
   },
   "source": [
    "## Matrix Multiplication\n",
    "In ml, matrix multiplication is one of the basic tesnor operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "id": "TAMYM0PAhIaC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[10  7]\n",
      " [ 3  4]], shape=(2, 2), dtype=int32)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tf.float32"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(tensor)\n",
    "tensor2=tf.reshape(tensor,shape=(4,1))\n",
    "tensor=tf.cast(tensor,dtype=tf.float32)\n",
    "tensor.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "id": "ax9bcBEjhIaC"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n",
       "array([[121.,  98.],\n",
       "       [ 42.,  37.]], dtype=float32)>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.matmul(tensor,tf.cast(tf.reshape(tensor2,shape=(2,2)),dtype=tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "id": "jFpEu7Sm1mVc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([2, 2])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "id": "GjlmSA0RyGwr"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n",
       "array([[121.,  98.],\n",
       "       [ 42.,  37.]], dtype=float32)>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#matrix multiplication in tensorflow\n",
    "tf.matmul(tensor,tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "PeV_7Yz4hIaD"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n",
       "array([[121.,  98.],\n",
       "       [ 42.,  37.]], dtype=float32)>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor @ tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "id": "RAe5M8Cc0x-K"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
       "array([[20, 59],\n",
       "       [34, 57],\n",
       "       [30, 60]], dtype=int32)>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test1=tf.constant([[1,2,5],[7,2,1],[3,3,3]])\n",
    "test2=tf.constant([[3,5],[6,7],[1,8]])\n",
    "tf.matmul(test1,test2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "id": "OQs9OG_r0kCT"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
       "array([[20, 59],\n",
       "       [34, 57],\n",
       "       [30, 60]], dtype=int32)>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Matrix multiplication with python operator\n",
    "test1 @ test2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "id": "kb0RQHaK35QI"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
       "array([[44, 20, 58],\n",
       "       [67, 37, 92],\n",
       "       [59, 13, 70]], dtype=int32)>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#matrix of same ndim cant be multiplied, so need to be reshaped\n",
    "test2_copy=tf.reshape(test2,shape=(2,3))\n",
    "tf.matmul(test2,test2_copy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "liMBG_Wk6CXn"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(TensorShape([2, 3]), TensorShape([3, 2]))"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tranpose\n",
    "tf.transpose(test2).shape,test2.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kpN14sQH62uH"
   },
   "source": [
    "##### multiplying with tranpose is not same as multiplying by reshaping, they give different results because in tranpose, axes are changed, but in reshape only re-shuffling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "id": "9beJLctM6q4U"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
       "array([[34, 53, 43],\n",
       "       [53, 85, 62],\n",
       "       [43, 62, 65]], dtype=int32)>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.matmul(test2,tf.transpose(test2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zVryQHOM7FWE"
   },
   "source": [
    "### The dot porduct\n",
    "Matrix multiplication is also called as dot product\n",
    "1. tf.matmul()\n",
    "2. tf.tensordot()\n",
    "3. @"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "id": "0TEI19zK7EWg"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]], shape=(3, 2), dtype=int32) tf.Tensor(\n",
      "[[ 7  8]\n",
      " [ 9 10]\n",
      " [11 12]], shape=(3, 2), dtype=int32)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       "array([[ 89,  98],\n",
       "       [116, 128]], dtype=int32)>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# perform dot product on X and Y, this X or Y to be transposed\n",
    "X=tf.constant([[1,2],[3,4],[5,6]])\n",
    "Y=tf.constant([[7,8],[9,10],[11,12]])\n",
    "print(X,Y)\n",
    "tf.tensordot(tf.transpose(X),Y,axes=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "id": "HSCVSR9S-bjM"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
       "array([[ 23,  29,  35],\n",
       "       [ 53,  67,  81],\n",
       "       [ 83, 105, 127]], dtype=int32)>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Perform matrix multiplication X and Y(transposed)\n",
    "tf.matmul(X,tf.transpose(Y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "id": "984jE4aA-mLj"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
       "array([[ 27,  30,  33],\n",
       "       [ 61,  68,  75],\n",
       "       [ 95, 106, 117]], dtype=int32)>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Perform matrix multiplication X and Y(reshaped)\n",
    "tf.matmul(X,tf.reshape(Y,shape=(2,3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "id": "Iz_blyaV-5av"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normal Y: \n",
      " tf.Tensor(\n",
      "[[ 7  8]\n",
      " [ 9 10]\n",
      " [11 12]], shape=(3, 2), dtype=int32)\n",
      "\n",
      "Y reshaped: \n",
      " tf.Tensor(\n",
      "[[ 7  8  9]\n",
      " [10 11 12]], shape=(2, 3), dtype=int32)\n",
      "\n",
      "Y Transposed: \n",
      " tf.Tensor(\n",
      "[[ 7  9 11]\n",
      " [ 8 10 12]], shape=(2, 3), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "# Check values of Y and transposed Y\n",
    "print(\"Normal Y: \\n\",Y)\n",
    "print(\"\\nY reshaped: \\n\",tf.reshape(Y,shape=(2,3)))\n",
    "print(\"\\nY Transposed: \\n\",tf.transpose(Y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wK_vlzXtAy9B"
   },
   "source": [
    "### Changing the datatype of the tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "id": "Y2ocki1lA0_e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([1.7 7.4], shape=(2,), dtype=float32) <dtype: 'float32'>\n",
      "tf.Tensor([1.7 7.4], shape=(2,), dtype=float16) <dtype: 'float16'>\n"
     ]
    }
   ],
   "source": [
    "# Create a new tensore with default datatype\n",
    "B = tf.constant([1.7,7.4])\n",
    "print(B,B.dtype)\n",
    "\n",
    "B = tf.cast(B,dtype=tf.float16)\n",
    "print(B,B.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "id": "0ihndJg2CvA2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([10,  7], dtype=int32)>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C=tf.constant([10,7])\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "id": "sVV38kLZCkO-"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(2,), dtype=float32, numpy=array([10.,  7.], dtype=float32)>,\n",
       " tf.float32)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# change from int32 to float32\n",
    "E = tf.cast(C,dtype=tf.float32)\n",
    "E,E.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AmfK7p5tDFDh"
   },
   "source": [
    "### Aggregating tensors\n",
    "Aggregating tensors = condensing them from multiple values down to a small amount of values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "id": "JeECK-LKC9r7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([ -7 -10], shape=(2,), dtype=int32)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([ 7, 10], dtype=int32)>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Getting the absolute values\n",
    "D = tf.constant([-7,-10])\n",
    "print(D)\n",
    "tf.abs(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CmcIiZNrMohH"
   },
   "source": [
    "#### forms of aggregation:\n",
    "1. Get the minimum of tensor\n",
    "2. Get the maximum of tensor\n",
    "3. Get the mean of the tensor\n",
    "4. Get the sum of the tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "id": "7ZwaL4QuMOd3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[43 70 47 90 70 95 82 78 62 29 79 54 58 16 87 66 28 62 73 92 39 59 91 81\n",
      " 25 49 59 86 49  8 88 79 18 56  2 79  7 19 58 94  9 53 81 49 78 90 63  0\n",
      " 67  3], shape=(50,), dtype=int64)\n",
      "Minimum:  0\n",
      "Maximum:  95\n",
      "mean:  56\n",
      "Sum of all elements:  2820\n",
      "Varience:  791.32\n",
      "Standard deviation:  28.130411\n"
     ]
    }
   ],
   "source": [
    "test = tf.constant(np.random.randint(0,100,size=50))\n",
    "print(test)\n",
    "print(\"Minimum: \",tf.reduce_min(test).numpy())\n",
    "print(\"Maximum: \",tf.reduce_max(test).numpy())\n",
    "print(\"mean: \",tf.reduce_mean(test).numpy())\n",
    "print(\"Sum of all elements: \",tf.reduce_sum(test).numpy())\n",
    "print(\"Varience: \",tf.math.reduce_variance(tf.cast(test,dtype=tf.float32)).numpy())\n",
    "print(\"Standard deviation: \",tf.math.reduce_std(tf.cast(test,dtype=tf.float32)).numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "id": "JZHUc25hQL8e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(), dtype=int64, numpy=791>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#another method to find varience and std:\n",
    "import tensorflow_probability as tfp\n",
    "tfp.stats.variance(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "id": "RXaw2gODQ3gd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positional maximun:  5 : 95\n",
      "Positional minimun:  47 : 0\n"
     ]
    }
   ],
   "source": [
    "# FInd the positional maximum and minimum of the tensor\n",
    "print(\"Positional maximun: \",tf.argmax(test).numpy(),\":\",test[tf.argmax(test).numpy()].numpy())\n",
    "print(\"Positional minimun: \",tf.argmin(test).numpy(),\":\",test[tf.argmin(test).numpy()].numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "id": "f7Z8Td62VEI7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(50,), dtype=float32, numpy=\n",
       "array([0.6645621 , 0.44100678, 0.3528825 , 0.46448255, 0.03366041,\n",
       "       0.68467236, 0.74011743, 0.8724445 , 0.22632635, 0.22319686,\n",
       "       0.3103881 , 0.7223358 , 0.13318717, 0.5480639 , 0.5746088 ,\n",
       "       0.8996835 , 0.00946367, 0.5212307 , 0.6345445 , 0.1993283 ,\n",
       "       0.72942245, 0.54583454, 0.10756552, 0.6767061 , 0.6602763 ,\n",
       "       0.33695042, 0.60141766, 0.21062577, 0.8527372 , 0.44062173,\n",
       "       0.9485276 , 0.23752594, 0.81179297, 0.5263394 , 0.494308  ,\n",
       "       0.21612847, 0.8457197 , 0.8718841 , 0.3083862 , 0.6868038 ,\n",
       "       0.23764038, 0.7817228 , 0.9671384 , 0.06870162, 0.79873943,\n",
       "       0.66028714, 0.5871513 , 0.16461694, 0.7381023 , 0.32054043],\n",
       "      dtype=float32)>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.random.set_seed(42)\n",
    "F = tf.random.uniform(shape=[50])\n",
    "F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "id": "TMlNEUAxVP6G"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(), dtype=bool, numpy=True>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find the posotional maximum of F\n",
    "F[tf.argmax(F)] == tf.reduce_max(F)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "auvauGRyX57u"
   },
   "source": [
    "### Squeezing a tensor(removing all the single dimesnion)\n",
    "\n",
    "Removes all the dimesions==1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "id": "HRAX1xjzV8rT"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(1, 1, 1, 1, 50), dtype=float32, numpy=\n",
       " array([[[[[0.6645621 , 0.44100678, 0.3528825 , 0.46448255, 0.03366041,\n",
       "            0.68467236, 0.74011743, 0.8724445 , 0.22632635, 0.22319686,\n",
       "            0.3103881 , 0.7223358 , 0.13318717, 0.5480639 , 0.5746088 ,\n",
       "            0.8996835 , 0.00946367, 0.5212307 , 0.6345445 , 0.1993283 ,\n",
       "            0.72942245, 0.54583454, 0.10756552, 0.6767061 , 0.6602763 ,\n",
       "            0.33695042, 0.60141766, 0.21062577, 0.8527372 , 0.44062173,\n",
       "            0.9485276 , 0.23752594, 0.81179297, 0.5263394 , 0.494308  ,\n",
       "            0.21612847, 0.8457197 , 0.8718841 , 0.3083862 , 0.6868038 ,\n",
       "            0.23764038, 0.7817228 , 0.9671384 , 0.06870162, 0.79873943,\n",
       "            0.66028714, 0.5871513 , 0.16461694, 0.7381023 , 0.32054043]]]]],\n",
       "       dtype=float32)>,\n",
       " TensorShape([1, 1, 1, 1, 50]))"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.random.set_seed(42)\n",
    "G = tf.constant(tf.random.uniform(shape=[50]),shape=[1,1,1,1,50])\n",
    "G,G.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "id": "wBhcxSNLYYUF"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(50,), dtype=float32, numpy=\n",
       " array([0.6645621 , 0.44100678, 0.3528825 , 0.46448255, 0.03366041,\n",
       "        0.68467236, 0.74011743, 0.8724445 , 0.22632635, 0.22319686,\n",
       "        0.3103881 , 0.7223358 , 0.13318717, 0.5480639 , 0.5746088 ,\n",
       "        0.8996835 , 0.00946367, 0.5212307 , 0.6345445 , 0.1993283 ,\n",
       "        0.72942245, 0.54583454, 0.10756552, 0.6767061 , 0.6602763 ,\n",
       "        0.33695042, 0.60141766, 0.21062577, 0.8527372 , 0.44062173,\n",
       "        0.9485276 , 0.23752594, 0.81179297, 0.5263394 , 0.494308  ,\n",
       "        0.21612847, 0.8457197 , 0.8718841 , 0.3083862 , 0.6868038 ,\n",
       "        0.23764038, 0.7817228 , 0.9671384 , 0.06870162, 0.79873943,\n",
       "        0.66028714, 0.5871513 , 0.16461694, 0.7381023 , 0.32054043],\n",
       "       dtype=float32)>,\n",
       " TensorShape([50]))"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G_squeezed=tf.squeeze(G)\n",
    "G_squeezed,G_squeezed.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fhaGIxbpYzM4"
   },
   "source": [
    "### One-hot encoding tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "id": "0mJu_6fTY31f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(4, 4), dtype=float32, numpy=\n",
       "array([[1., 0., 0., 0.],\n",
       "       [0., 1., 0., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [0., 0., 0., 1.]], dtype=float32)>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Create a list\n",
    "some_list = [0,1,2,3]\n",
    "\n",
    "#One hot:\n",
    "tf.one_hot(some_list, depth=len(some_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "id": "tVGk58OzdiLO"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(4, 4), dtype=int32, numpy=\n",
       "array([[ 69, 420, 420, 420],\n",
       "       [420,  69, 420, 420],\n",
       "       [420, 420,  69, 420],\n",
       "       [420, 420, 420,  69]], dtype=int32)>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#specify custom values for one hot encoding\n",
    "tf.one_hot(some_list,depth=4,on_value=69,off_value=420)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2DVQGHLAw9oD"
   },
   "source": [
    "### Squaring,log and square root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "id": "oxVMbHvgxH87"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(9,), dtype=int32, numpy=array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H=tf.range(1,10)\n",
    "H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "id": "T-IIu5CIrDh2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(9,), dtype=int32, numpy=array([ 1,  4,  9, 16, 25, 36, 49, 64, 81], dtype=int32)>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a new tensor\n",
    "tf.square(H)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "id": "AwD8yYFVxMSj"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(9,), dtype=float32, numpy=\n",
       "array([1.       , 1.4142135, 1.7320508, 2.       , 2.2360678, 2.4494896,\n",
       "       2.6457512, 2.828427 , 3.       ], dtype=float32)>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Square root\n",
    "tf.sqrt(tf.cast(H,dtype=tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "id": "0W-8G7cjxUgj"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(9,), dtype=float32, numpy=\n",
       "array([0.       , 0.6931472, 1.0986123, 1.3862944, 1.609438 , 1.7917595,\n",
       "       1.9459102, 2.0794415, 2.1972246], dtype=float32)>"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Take log\n",
    "tf.math.log(tf.cast(H,dtype=tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "id": "UW3umdRoxzDK"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 4), dtype=int32, numpy=\n",
       "array([[2, 0, 0, 0],\n",
       "       [5, 6, 7, 8]], dtype=int32)>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tf.math.segment_sum()---when 1, it wont be used for addition, else it will be used for addition, further research needed\n",
    "test = tf.constant([[1,2,3,4],[1,-2,-3,-4],[5,6,7,8]])\n",
    "tf.math.segment_sum(test,tf.constant([0,0,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "id": "d2zc9uLA6bsz"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(), dtype=float32, numpy=0.0>,\n",
       " <tf.Tensor: shape=(), dtype=float64, numpy=inf>)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Safe divsion with tf.math.divide_no_nan(x,y)\n",
    "tf.math.divide_no_nan(12.0,0.0),tf.divide(12,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "id": "qKmVe6DAZrfe"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=bool, numpy=\n",
       "array([[ True, False],\n",
       "       [False,  True]])>"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Logical or operation\n",
    "x=tf.constant([[True,False],[False,True]])\n",
    "tf.math.logical_or(x,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "id": "OBq-PkdMaW0d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 4), dtype=int32, numpy=\n",
       "array([[  5,  10,  15,  20],\n",
       "       [  5, -10, -15, -20],\n",
       "       [ 25,  30,  35,  40]], dtype=int32)>"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multiplies a tensor by a scalar\n",
    "tf.scalar_mul(5,test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 4), dtype=int32, numpy=\n",
       "array([[  5,  10,  15,  20],\n",
       "       [  5, -10, -15, -20],\n",
       "       [ 25,  30,  35,  40]], dtype=int32)>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "id": "KGSAwb0GbnDM"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(5, 20), dtype=float32, numpy=\n",
       " array([[1.000e+00, 4.000e+00, 9.000e+00, 1.600e+01, 2.500e+01, 3.600e+01,\n",
       "         4.900e+01, 6.400e+01, 8.100e+01, 1.000e+02, 1.210e+02, 1.440e+02,\n",
       "         1.690e+02, 1.960e+02, 2.250e+02, 2.560e+02, 2.890e+02, 3.240e+02,\n",
       "         3.610e+02, 4.000e+02],\n",
       "        [4.410e+02, 4.840e+02, 5.290e+02, 5.760e+02, 6.250e+02, 6.760e+02,\n",
       "         7.290e+02, 7.840e+02, 8.410e+02, 9.000e+02, 9.610e+02, 1.024e+03,\n",
       "         1.089e+03, 1.156e+03, 1.225e+03, 1.296e+03, 1.369e+03, 1.444e+03,\n",
       "         1.521e+03, 1.600e+03],\n",
       "        [1.681e+03, 1.764e+03, 1.849e+03, 1.936e+03, 2.025e+03, 2.116e+03,\n",
       "         2.209e+03, 2.304e+03, 2.401e+03, 2.500e+03, 2.601e+03, 2.704e+03,\n",
       "         2.809e+03, 2.916e+03, 3.025e+03, 3.136e+03, 3.249e+03, 3.364e+03,\n",
       "         3.481e+03, 3.600e+03],\n",
       "        [3.721e+03, 3.844e+03, 3.969e+03, 4.096e+03, 4.225e+03, 4.356e+03,\n",
       "         4.489e+03, 4.624e+03, 4.761e+03, 4.900e+03, 5.041e+03, 5.184e+03,\n",
       "         5.329e+03, 5.476e+03, 5.625e+03, 5.776e+03, 5.929e+03, 6.084e+03,\n",
       "         6.241e+03, 6.400e+03],\n",
       "        [6.561e+03, 6.724e+03, 6.889e+03, 7.056e+03, 7.225e+03, 7.396e+03,\n",
       "         7.569e+03, 7.744e+03, 7.921e+03, 8.100e+03, 8.281e+03, 8.464e+03,\n",
       "         8.649e+03, 8.836e+03, 9.025e+03, 9.216e+03, 9.409e+03, 9.604e+03,\n",
       "         9.801e+03, 1.000e+04]], dtype=float32)>,\n",
       " <tf.Tensor: shape=(5, 20), dtype=float32, numpy=\n",
       " array([[0.       , 0.6931472, 1.0986123, 1.3862944, 1.609438 , 1.7917595,\n",
       "         1.9459102, 2.0794415, 2.1972246, 2.3025851, 2.3978953, 2.4849067,\n",
       "         2.5649493, 2.6390574, 2.7080503, 2.7725887, 2.8332133, 2.8903718,\n",
       "         2.944439 , 2.9957323],\n",
       "        [3.0445225, 3.0910425, 3.1354942, 3.1780539, 3.218876 , 3.2580965,\n",
       "         3.295837 , 3.3322046, 3.3672957, 3.4011974, 3.4339871, 3.465736 ,\n",
       "         3.4965076, 3.5263605, 3.5553482, 3.583519 , 3.610918 , 3.637586 ,\n",
       "         3.6635616, 3.6888795],\n",
       "        [3.713572 , 3.7376697, 3.7612002, 3.7841897, 3.8066626, 3.8286414,\n",
       "         3.8501477, 3.871201 , 3.8918204, 3.912023 , 3.9318256, 3.9512436,\n",
       "         3.9702919, 3.988984 , 4.0073333, 4.0253515, 4.0430512, 4.060443 ,\n",
       "         4.0775375, 4.0943446],\n",
       "        [4.1108737, 4.1271343, 4.1431346, 4.158883 , 4.1743875, 4.189655 ,\n",
       "         4.204693 , 4.2195077, 4.2341065, 4.248495 , 4.26268  , 4.276666 ,\n",
       "         4.2904596, 4.304065 , 4.317488 , 4.3307333, 4.3438053, 4.356709 ,\n",
       "         4.3694477, 4.3820267],\n",
       "        [4.394449 , 4.406719 , 4.4188404, 4.4308167, 4.4426513, 4.454347 ,\n",
       "         4.465908 , 4.477337 , 4.4886365, 4.4998097, 4.5108595, 4.5217886,\n",
       "         4.5325994, 4.543295 , 4.553877 , 4.564348 , 4.574711 , 4.5849676,\n",
       "         4.59512  , 4.6051702]], dtype=float32)>,\n",
       " <tf.Tensor: shape=(5, 20), dtype=float32, numpy=\n",
       " array([[ 1.       ,  1.4142135,  1.7320508,  2.       ,  2.2360678,\n",
       "          2.4494896,  2.6457512,  2.828427 ,  3.       ,  3.1622777,\n",
       "          3.3166246,  3.4641016,  3.6055512,  3.7416573,  3.8729832,\n",
       "          4.       ,  4.1231055,  4.2426405,  4.3588986,  4.4721355],\n",
       "        [ 4.5825753,  4.6904154,  4.795831 ,  4.898979 ,  5.       ,\n",
       "          5.0990195,  5.196152 ,  5.2915025,  5.3851647,  5.4772253,\n",
       "          5.5677643,  5.656854 ,  5.7445626,  5.8309517,  5.9160795,\n",
       "          6.       ,  6.0827622,  6.164414 ,  6.244998 ,  6.3245554],\n",
       "        [ 6.403124 ,  6.4807405,  6.5574384,  6.6332493,  6.708204 ,\n",
       "          6.7823296,  6.8556542,  6.928203 ,  7.       ,  7.071068 ,\n",
       "          7.1414285,  7.2111025,  7.28011  ,  7.3484693,  7.4161983,\n",
       "          7.4833145,  7.5498343,  7.6157727,  7.6811457,  7.7459664],\n",
       "        [ 7.8102493,  7.8740077,  7.937254 ,  8.       ,  8.062258 ,\n",
       "          8.124038 ,  8.185352 ,  8.246211 ,  8.306623 ,  8.3666   ,\n",
       "          8.426149 ,  8.485281 ,  8.5440035,  8.6023245,  8.660254 ,\n",
       "          8.717797 ,  8.774964 ,  8.83176  ,  8.888194 ,  8.944271 ],\n",
       "        [ 9.       ,  9.055385 ,  9.110434 ,  9.165151 ,  9.219544 ,\n",
       "          9.273618 ,  9.327378 ,  9.380831 ,  9.433981 ,  9.486833 ,\n",
       "          9.5393915,  9.591662 ,  9.64365  ,  9.695359 ,  9.746794 ,\n",
       "          9.797958 ,  9.848858 ,  9.899494 ,  9.949874 , 10.       ]],\n",
       "       dtype=float32)>)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Squaring,log and sqrt\n",
    "x = tf.range(1,101)\n",
    "x=tf.reshape(x,(5,20))\n",
    "x=tf.cast(x,dtype=tf.float32)\n",
    "tf.square(x),tf.math.log(x),tf.sqrt(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F29s79dQeMdB"
   },
   "source": [
    "### Tensors and Numpy Compatibility\n",
    "\n",
    "Tensorflow interacts with NumPy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "id": "WBJJOycedA1K"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(4,), dtype=int64, numpy=array([ 3,  4, 62,  3])>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a tensor directly from Numpy array\n",
    "J = tf.constant(np.array([3,4,62,3]))\n",
    "J"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "id": "DuX0jvlmemqg"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 3,  4, 62,  3]), array([ 3,  4, 62,  3]))"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert back the tensor back to numpy array\n",
    "np.array(J),J.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "id": "vSLVixiUeuVx"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tf.float32, tf.float64)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The default types of each differ\n",
    "npJ=tf.constant(np.array([3.,46.,215.,6.]))\n",
    "TensorJ=tf.constant([3.,7.,10.])\n",
    "#check the dtype of each\n",
    "TensorJ.dtype,npJ.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OnhprWKDgA15"
   },
   "source": [
    "### Finding access to GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "id": "YTe0whokfYm-"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.config.list_physical_devices(\"GPU\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "id": "CHAj0_a_gWV3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sun Dec 31 21:48:07 2023       \n",
      "+---------------------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 545.23.08              Driver Version: 545.23.08    CUDA Version: 12.3     |\n",
      "|-----------------------------------------+----------------------+----------------------+\n",
      "| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                                         |                      |               MIG M. |\n",
      "|=========================================+======================+======================|\n",
      "|   0  NVIDIA GeForce RTX 3050 ...    On  | 00000000:01:00.0 Off |                  N/A |\n",
      "| N/A   58C    P0              15W /  60W |   3693MiB /  4096MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "                                                                                         \n",
      "+---------------------------------------------------------------------------------------+\n",
      "| Processes:                                                                            |\n",
      "|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |\n",
      "|        ID   ID                                                             Usage      |\n",
      "|=======================================================================================|\n",
      "|    0   N/A  N/A      1126      G   /usr/lib/xorg/Xorg                            4MiB |\n",
      "|    0   N/A  N/A     11815      C   ...l/miniconda3/envs/tf2.13/bin/python     3680MiB |\n",
      "+---------------------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4_XHEl4lis_n"
   },
   "source": [
    "## EXERCISE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "id": "g4LQ3KjQhXm8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(4,), dtype=int32, numpy=array([1, 2, 3, 4], dtype=int32)>,\n",
       " <tf.Tensor: shape=(), dtype=int32, numpy=3>,\n",
       " <tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       " array([[10,  7],\n",
       "        [ 3,  4]], dtype=int32)>)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 1 Create a vector,scalar,matrix and tensor with values of your choosing using tf.constant()\n",
    "a=tf.constant([1,2,3,4])\n",
    "b=tf.constant(3)\n",
    "c=tf.constant([[10,7],\n",
    "             [3,4]])\n",
    "a,b,c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "id": "bbiDlX3yjTih"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4,) () (2, 2)\n",
      "1 0 2\n",
      "4 1 4\n"
     ]
    }
   ],
   "source": [
    "# 2 Find the shape,rank and size of tensors created in 1\n",
    "print(a.shape,b.shape,c.shape)\n",
    "print(tf.rank(a).numpy(),tf.rank(b).numpy(),tf.rank(c).numpy())\n",
    "print(tf.size(a).numpy(),tf.size(b).numpy(),tf.size(c).numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "id": "Yw9nYzhTKnrB"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(5, 30), dtype=float32, numpy=\n",
       " array([[0.68789124, 0.48447883, 0.9309944 , 0.252187  , 0.73115396,\n",
       "         0.89256823, 0.94674826, 0.7493341 , 0.34925628, 0.54718256,\n",
       "         0.26160395, 0.69734323, 0.11962581, 0.53484344, 0.7148968 ,\n",
       "         0.87501776, 0.33967495, 0.17377627, 0.4418521 , 0.9008261 ,\n",
       "         0.13803864, 0.12217975, 0.5754491 , 0.9417181 , 0.9186585 ,\n",
       "         0.59708476, 0.6109482 , 0.82086265, 0.83269787, 0.8915849 ],\n",
       "        [0.01377225, 0.49807465, 0.57503664, 0.6856195 , 0.75972784,\n",
       "         0.908944  , 0.40900218, 0.8765154 , 0.53890026, 0.42733097,\n",
       "         0.401173  , 0.66623247, 0.16348064, 0.18220246, 0.97040176,\n",
       "         0.06139731, 0.53034747, 0.9869994 , 0.4746945 , 0.8646754 ,\n",
       "         0.20301068, 0.11448455, 0.35100245, 0.68227184, 0.18108869,\n",
       "         0.8163481 , 0.65651655, 0.9258256 , 0.2391715 , 0.8365958 ],\n",
       "        [0.04765272, 0.8007157 , 0.8299267 , 0.14328372, 0.8616878 ,\n",
       "         0.9707202 , 0.6779593 , 0.5641242 , 0.62537   , 0.8653159 ,\n",
       "         0.16104567, 0.11101365, 0.61647224, 0.60355604, 0.6303868 ,\n",
       "         0.5213008 , 0.8186623 , 0.20569968, 0.19041789, 0.14648688,\n",
       "         0.14919603, 0.8594816 , 0.9167328 , 0.5044954 , 0.8656684 ,\n",
       "         0.70333743, 0.5343715 , 0.35093033, 0.63313484, 0.84159875],\n",
       "        [0.4346044 , 0.29658782, 0.849067  , 0.20556164, 0.39022648,\n",
       "         0.59092   , 0.8787719 , 0.7197267 , 0.09947217, 0.9480752 ,\n",
       "         0.4462725 , 0.336092  , 0.44687068, 0.7897918 , 0.61746264,\n",
       "         0.54826057, 0.93602526, 0.19893539, 0.8555646 , 0.2972008 ,\n",
       "         0.12980974, 0.5903213 , 0.07226849, 0.7990017 , 0.37418842,\n",
       "         0.8004397 , 0.07435453, 0.4683442 , 0.3976704 , 0.4365393 ],\n",
       "        [0.23953521, 0.7249464 , 0.4366442 , 0.5428084 , 0.9501494 ,\n",
       "         0.51135266, 0.9495735 , 0.10583961, 0.7803346 , 0.93132937,\n",
       "         0.9163221 , 0.74123394, 0.33278155, 0.8980862 , 0.34247506,\n",
       "         0.57605577, 0.994889  , 0.63498044, 0.90795994, 0.6835562 ,\n",
       "         0.34189606, 0.37006962, 0.38349402, 0.961771  , 0.528049  ,\n",
       "         0.2033298 , 0.28053653, 0.6861787 , 0.8305216 , 0.17295063]],\n",
       "       dtype=float32)>,\n",
       " <tf.Tensor: shape=(5, 30), dtype=float32, numpy=\n",
       " array([[0.7413678 , 0.62854624, 0.01738465, 0.3431449 , 0.51063764,\n",
       "         0.3777541 , 0.07321596, 0.02137029, 0.2871771 , 0.4710616 ,\n",
       "         0.6936141 , 0.07321334, 0.93251204, 0.20843053, 0.70105827,\n",
       "         0.45856392, 0.8596262 , 0.92934334, 0.20291913, 0.76865506,\n",
       "         0.60016024, 0.27039742, 0.88180614, 0.05365038, 0.42274463,\n",
       "         0.89037776, 0.7887033 , 0.10165584, 0.19408834, 0.27896714],\n",
       "        [0.39512634, 0.12235212, 0.38412368, 0.9455296 , 0.77594674,\n",
       "         0.94442344, 0.04296565, 0.4746096 , 0.6548251 , 0.5657116 ,\n",
       "         0.13858628, 0.3004663 , 0.3311677 , 0.12907016, 0.6435652 ,\n",
       "         0.45473957, 0.68881893, 0.30203617, 0.49152803, 0.26529062,\n",
       "         0.7122741 , 0.72297084, 0.18866003, 0.24155617, 0.8013923 ,\n",
       "         0.9717448 , 0.704507  , 0.28954244, 0.5491171 , 0.05062342],\n",
       "        [0.1928184 , 0.4541731 , 0.21889174, 0.87243795, 0.56308484,\n",
       "         0.316792  , 0.68497694, 0.39252186, 0.7106304 , 0.7038053 ,\n",
       "         0.71630967, 0.8375633 , 0.9909723 , 0.94025004, 0.21663237,\n",
       "         0.7143645 , 0.539435  , 0.5229018 , 0.3451408 , 0.969429  ,\n",
       "         0.9890361 , 0.31063735, 0.9489944 , 0.59065425, 0.5401238 ,\n",
       "         0.26383626, 0.49390125, 0.51443005, 0.69443834, 0.37080622],\n",
       "        [0.51013005, 0.91926074, 0.20885623, 0.4022926 , 0.26109898,\n",
       "         0.91494703, 0.87439096, 0.16771638, 0.6596291 , 0.8011217 ,\n",
       "         0.03326142, 0.5679704 , 0.2947669 , 0.95180404, 0.42315996,\n",
       "         0.8294318 , 0.21666467, 0.276919  , 0.2744521 , 0.7441251 ,\n",
       "         0.9237778 , 0.87372565, 0.8173491 , 0.95248055, 0.9349098 ,\n",
       "         0.3453257 , 0.82638395, 0.257635  , 0.54752195, 0.3548969 ],\n",
       "        [0.45873654, 0.99113786, 0.42692852, 0.6182103 , 0.6676439 ,\n",
       "         0.8054024 , 0.8585732 , 0.4297372 , 0.8957572 , 0.1445055 ,\n",
       "         0.74193025, 0.4329232 , 0.7495061 , 0.4628352 , 0.5023675 ,\n",
       "         0.597067  , 0.38990688, 0.12060452, 0.61893713, 0.2203505 ,\n",
       "         0.7606771 , 0.5109856 , 0.26882923, 0.25886452, 0.08104873,\n",
       "         0.80274415, 0.56557393, 0.01859415, 0.32432842, 0.42752385]],\n",
       "       dtype=float32)>)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3 Create two tensors containing random values between 0 and 1 with shape [5,300]\n",
    "x = tf.random.uniform(shape=(5,30))\n",
    "y = tf.random.uniform(shape=(5,30))\n",
    "x,y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "id": "SsEmAmwJLVjw"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(5, 5), dtype=float32, numpy=\n",
       "array([[ 7.234152 ,  8.23665  , 10.083019 , 10.768001 ,  8.554802 ],\n",
       "       [ 7.2586665,  7.8247647,  8.776067 ,  8.214537 ,  7.785835 ],\n",
       "       [ 7.569828 ,  8.359356 ,  9.295924 , 10.165113 ,  8.594623 ],\n",
       "       [ 6.0828457,  7.0659194,  8.098655 ,  8.267043 ,  7.473749 ],\n",
       "       [ 7.6864076,  8.073923 , 11.181822 , 10.456644 ,  8.971824 ]],\n",
       "      dtype=float32)>"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 4 Multiply the two tensors created in 3 using matrix multiplication\n",
    "tf.matmul(x,tf.transpose(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "id": "atQ2aim3LhD7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(5, 5), dtype=float32, numpy=\n",
       "array([[ 7.234152 ,  8.23665  , 10.083019 , 10.768001 ,  8.554802 ],\n",
       "       [ 7.2586665,  7.8247647,  8.776067 ,  8.214537 ,  7.785835 ],\n",
       "       [ 7.569828 ,  8.359356 ,  9.295924 , 10.165113 ,  8.594623 ],\n",
       "       [ 6.0828457,  7.0659194,  8.098655 ,  8.267043 ,  7.473749 ],\n",
       "       [ 7.6864076,  8.073923 , 11.181822 , 10.456644 ,  8.971824 ]],\n",
       "      dtype=float32)>"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 5 Multiply two sensors created in 3 using dot product\n",
    "tf.tensordot(x,tf.transpose(y),axes=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "id": "wfska9oSL-Bp"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(224, 224, 3), dtype=float32, numpy=\n",
       "array([[[7.4023080e-01, 3.3938193e-01, 5.6925058e-01],\n",
       "        [4.4811392e-01, 2.9285502e-01, 4.2600560e-01],\n",
       "        [6.2890387e-01, 6.9106102e-01, 3.0925727e-01],\n",
       "        ...,\n",
       "        [9.1063976e-04, 6.9863999e-01, 1.7180574e-01],\n",
       "        [6.7542684e-01, 8.3492923e-01, 3.9038682e-01],\n",
       "        [2.3664141e-01, 6.2239432e-01, 1.0117912e-01]],\n",
       "\n",
       "       [[9.7064960e-01, 5.4594779e-01, 7.6819682e-01],\n",
       "        [2.6893330e-01, 2.6959443e-01, 2.8982997e-01],\n",
       "        [2.9215467e-01, 1.7108858e-01, 6.5597153e-01],\n",
       "        ...,\n",
       "        [9.5621395e-01, 5.4591870e-01, 5.3843534e-01],\n",
       "        [9.8861516e-01, 1.5786767e-01, 6.1375093e-01],\n",
       "        [7.2668612e-01, 6.1637163e-03, 1.6534305e-01]],\n",
       "\n",
       "       [[6.4095867e-01, 7.6697862e-01, 3.0138540e-01],\n",
       "        [1.5474892e-01, 1.7183411e-01, 2.7192724e-01],\n",
       "        [3.1211805e-01, 6.1451709e-01, 4.3001354e-01],\n",
       "        ...,\n",
       "        [8.4168065e-01, 5.0247252e-01, 2.8834987e-01],\n",
       "        [3.3173549e-01, 4.5103800e-01, 6.7354202e-02],\n",
       "        [1.0118127e-01, 4.2389810e-01, 6.8379509e-01]],\n",
       "\n",
       "       ...,\n",
       "\n",
       "       [[1.8096626e-01, 8.5838544e-01, 3.4178734e-02],\n",
       "        [5.9386420e-01, 3.8502932e-01, 8.7150073e-01],\n",
       "        [1.0209656e-01, 3.7833798e-01, 1.1331165e-01],\n",
       "        ...,\n",
       "        [8.5692227e-01, 4.2525017e-01, 3.6130440e-01],\n",
       "        [5.2397156e-01, 1.3922489e-01, 2.2725856e-01],\n",
       "        [9.1044855e-01, 9.1889143e-02, 1.5898192e-01]],\n",
       "\n",
       "       [[6.5610647e-02, 1.5236783e-01, 7.9822493e-01],\n",
       "        [3.0753601e-01, 4.3507314e-01, 7.9526460e-01],\n",
       "        [8.3535135e-01, 3.8671303e-01, 4.4709980e-01],\n",
       "        ...,\n",
       "        [6.8944788e-01, 6.5163302e-01, 9.1498744e-01],\n",
       "        [3.2730651e-01, 4.3430209e-01, 8.7547708e-01],\n",
       "        [1.8118513e-01, 6.4113998e-01, 4.3338275e-01]],\n",
       "\n",
       "       [[4.1520441e-01, 1.7824161e-01, 9.2302203e-02],\n",
       "        [4.3809581e-01, 4.6262145e-01, 3.8647270e-01],\n",
       "        [4.6021819e-02, 7.6314330e-02, 3.2944894e-01],\n",
       "        ...,\n",
       "        [3.7793708e-01, 8.7314355e-01, 5.2063870e-01],\n",
       "        [7.3511279e-01, 7.9594767e-01, 8.2211494e-02],\n",
       "        [9.7483528e-01, 8.2736588e-01, 7.6870322e-01]]], dtype=float32)>"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 6 Create a tensor with random values between 0 and 1 with shape [224,224,3]\n",
    "test=tf.random.uniform(shape=(224,224,3))\n",
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "id": "_GR5P-IEMo7Z"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0967255e-05, 0.9999902)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 7 Find the min and max values of the tensor created in 6\n",
    "tf.reduce_min(test).numpy(),tf.reduce_max(test).numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "id": "X0MxoyVoM2IQ"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(TensorShape([1, 224, 224, 3]), TensorShape([224, 224, 3]))"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 8 Create a tensor with shape [1,224,224,3] and squeeze it to [224,224,3]\n",
    "test=tf.random.uniform(shape=(1,224,224,3))\n",
    "test.shape,tf.squeeze(test).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "id": "ZvZoJUH8NHxg"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<tf.Tensor: shape=(), dtype=bool, numpy=True>,\n",
       " <tf.Tensor: shape=(), dtype=int64, numpy=0>)"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 9 Create a tensor with shape [10] and find the index of the max value\n",
    "test=tf.random.uniform(shape=(10,),minval=1,maxval=11)\n",
    "test[tf.argmax(test)]==tf.reduce_max(test),tf.argmax(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "id": "gAd5UAtpNe61"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(10, 10), dtype=float32, numpy=\n",
       "array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
       "       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.]], dtype=float32)>"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 10 One-hot encode the tensor created in 9\n",
    "tf.one_hot(tf.cast(test,dtype=tf.int32),depth=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[-0.7565803 , -0.06854702],\n",
       "       [ 0.07595026, -1.2573844 ],\n",
       "       [-0.23193765, -1.8107855 ]], dtype=float32)>"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = tf.random.Generator.from_seed(42)\n",
    "x = x.normal(shape=(3,2))\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[0.6645621 , 0.44100678],\n",
       "       [0.3528825 , 0.46448255],\n",
       "       [0.03366041, 0.68467236]], dtype=float32)>"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.random.set_seed(42)\n",
    "tf.random.uniform(shape=(3,2))"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "private_outputs": true,
   "provenance": []
  },
  "gpuClass": "standard",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.2"
  },
  "vscode": {
   "interpreter": {
    "hash": "90776d58026cf23f204e10ffddeb023f215096344894fc4b73554138ee1bdcfb"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}