00_tensorflow_fundamentals.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# In this notebook, we're going to cover some of the most fundamental concepts of tensorflow\n",
        "\n",
        "We're going to cover\n",
        "\n",
        "* Introduction to tensors\n",
        "* Getting information from tensors\n",
        "* Manipulating tensors\n",
        "* Tensors & Numpy\n",
        "* Using @tf.function( a way to speed up python functions)\n",
        "* Using GPUS with tensorflow or TPUS\n",
        "* Exercises to try\n"
      ],
      "metadata": {
        "id": "lT2SlUsrXqf9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Introduction to Tensorflow"
      ],
      "metadata": {
        "id": "ZueMPi3JYARc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# import tensorflow\n",
        "import tensorflow as tf\n",
        "print(tf.__version__)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UHaay7QcYT1X",
        "outputId": "5abb1441-6ec1-41c8-c953-258b40ee03d7"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.15.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create tensors with tf.constant()\n",
        "scalar = tf.constant(7)\n",
        "scalar"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qyC2LLtxYZeD",
        "outputId": "1cab227a-1c76-4c56-b4d2-21ed7391b15e"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int32, numpy=7>"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check the number of dimensions of a tensor (ndim = number of dimensions)\n",
        "scalar.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fz-6KrqQYpYF",
        "outputId": "fb762b57-e0a7-41cd-d237-d89c3a7c721d"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a vector\n",
        "vector = tf.constant([10,10])\n",
        "vector"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qL2F5fH1Y8RO",
        "outputId": "b15e8135-b445-4b8e-bc46-a4306d5e6f05"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([10, 10], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check the dimension of our vector\n",
        "vector.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tqSFBnPKZCYA",
        "outputId": "20c95881-42c7-40c7-f071-022be784e530"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a matrix(matrix has more than 1 dimensions)\n",
        "matrix = tf.constant([[10,7],[7,10]])\n",
        "matrix"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2t22443TZKT1",
        "outputId": "d9150995-c7bb-4ed7-e56a-ce13ffb366d3"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[10,  7],\n",
              "       [ 7, 10]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "matrix.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V1Mf_QFPZVkp",
        "outputId": "53f4a480-61e9-4da5-a4bb-6e79c571d39e"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create another matrix(matrix has more than 1 dimensions)\n",
        "another_matrix = tf.constant([[10.,7.],[7.,10.],[8.,9.]],dtype=tf.float16) # Create a matrix of 3 dimensions with values of float16\n",
        "another_matrix"
      ],
      "metadata": {
        "id": "39N5K_ueZnad",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b6938991-902a-459f-ced8-d0c00583fa24"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=float16, numpy=\n",
              "array([[10.,  7.],\n",
              "       [ 7., 10.],\n",
              "       [ 8.,  9.]], dtype=float16)>"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "another_matrix.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fypGGbE-Z56C",
        "outputId": "d891c3bd-0ee9-4861-b1b9-5ba651ae4518"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Tensor\n",
        "tensor = tf.constant([[[1,2,3,],[4,5,6]],[[7,8,9],[10,11,12]],[[13,14,15],[16,17,18]]])\n",
        "tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GiH4CyJiaady",
        "outputId": "c64b8a92-76f4-44ab-956a-4692186b4bd6"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "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)>"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "IHZMY4CqaZtS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jUTO9FLxZ7hJ",
        "outputId": "4ca5412f-191b-48ca-de12-a74f0eed13fe"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## What we've created so far\n",
        "\n",
        "* Scalar is single number\n",
        "* Vector is a number with direction\n",
        "* Matrix is a 2 dimensional array of numbers\n",
        "* Tensor is an n-dimensional array of numbers where n can be any number"
      ],
      "metadata": {
        "id": "Fdgb1eEyasN1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating tf variable"
      ],
      "metadata": {
        "id": "9Nuw_YKmbnoe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create same tensor using variable as we had previously\n",
        "changeable_tensor = tf.Variable([10,7])\n",
        "unchangeable_tensor = tf.constant([10,7])\n",
        "changeable_tensor, unchangeable_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9dkbH3hHbLcS",
        "outputId": "cccac2cc-af24-4ba6-9c25-ba1bb126492c"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Variable 'Variable:0' shape=(2,) dtype=int32, numpy=array([10,  7], dtype=int32)>,\n",
              " <tf.Tensor: shape=(2,), dtype=int32, numpy=array([10,  7], dtype=int32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#changeable_tensor[0] = 7"
      ],
      "metadata": {
        "id": "vznxq3tXbbCv"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# using assign\n",
        "changeable_tensor[0].assign(7)\n",
        "changeable_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-lvgnqRxcIT8",
        "outputId": "a948bca7-c967-4d44-de06-5ab008c72e3f"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Variable 'Variable:0' shape=(2,) dtype=int32, numpy=array([7, 7], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# lets try changing unchangeable\n",
        "#unchangeable_tensor[0].assign(7)\n",
        "#unchangeable_tensor"
      ],
      "metadata": {
        "id": "lsFhnbiRcRyv"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating random tensors\n",
        "\n",
        "Random tensors are tensors of some arbitrary size filled with random numbers"
      ],
      "metadata": {
        "id": "OTyxMD1Ocmgu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "### Let's create 2 random tensors of 2 sizes\n",
        "random_1 = tf.random.Generator.from_seed(42)\n",
        "random_1 = random_1.normal(shape=(3,2))\n",
        "print(random_1)\n",
        "random_2 = tf.random.Generator.from_seed(7)\n",
        "random_2 = random_2.normal(shape=(3,2))\n",
        "print(random_2)\n",
        "random_1 == random_2"
      ],
      "metadata": {
        "id": "pmsFt002cY6u",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "02d660a9-27d6-49ed-c250-5f50a67e1985"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[-0.7565803  -0.06854702]\n",
            " [ 0.07595026 -1.2573844 ]\n",
            " [-0.23193765 -1.8107855 ]], shape=(3, 2), dtype=float32)\n",
            "tf.Tensor(\n",
            "[[-1.3240396   0.2878567 ]\n",
            " [-0.87579006 -0.08857017]\n",
            " [ 0.69211644  0.84215707]], shape=(3, 2), dtype=float32)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
              "array([[False, False],\n",
              "       [False, False],\n",
              "       [False, False]])>"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### shuffle order of elements in tensor"
      ],
      "metadata": {
        "id": "ffMjG2Ssq-fr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "### shuffle order of elements in tensor good for model training\n",
        "not_shuffled = tf.constant([[10,7],[3,4],[2,5]])\n",
        "not_shuffled.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QutE-0LYq-t6",
        "outputId": "52485cb3-6329-4db0-bc9e-3496f470ce5f"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "not_shuffled"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6qECh9eBp8nv",
        "outputId": "8a5e35c9-cd4c-4de9-f764-0ddfa15027b8"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              "array([[10,  7],\n",
              "       [ 3,  4],\n",
              "       [ 2,  5]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# shuffle not shuffled tensor\n",
        "tf.random.set_seed(42)\n",
        "shuffled = tf.random.shuffle(not_shuffled,seed=42)\n",
        "shuffled"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "omUsD8HfroJG",
        "outputId": "b1faaedb-bdb8-486b-f37d-88034b8265f6"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              "array([[10,  7],\n",
              "       [ 3,  4],\n",
              "       [ 2,  5]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Exercise*** read through tensorflow documentation on random seed generation\n",
        "\n",
        "Important note would need to set global and operator seed to get same result everytime to allow reproduction"
      ],
      "metadata": {
        "id": "8Fyj5dI8svIt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# create tensors of all ones\n",
        "tf.ones([10,7])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8TyZtsrxruOD",
        "outputId": "9ee15db9-bb3c-4e17-dd36-799decf5c9a1"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "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)>"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# create tensors of all zeros\n",
        "tf.zeros([10,7])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DQ5X53XnuYP2",
        "outputId": "f65c6265-dae3-4aa2-fb19-c99da886f1c9"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<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)>"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### turn numpy arrays into tensors\n",
        "Difference between numpy arrays and tensorflow tensors is that tensors can be run on a gpu"
      ],
      "metadata": {
        "id": "PaENDKQJwK95"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "### turn numpy arrays into tensors\n",
        "import numpy as np\n",
        "\n",
        "numpy_A = np.arange(1,25, dtype=np.int32) # Creates numpy array between 1 and 25\n",
        "\n",
        "# X = tf.constant(some_matrix)\n",
        "# Y = tf.constant[vector]\n",
        "numpy_A"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "idarFTYjuSLd",
        "outputId": "82ca0972-2ca2-454c-847f-6f92ca4108af"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
              "       18, 19, 20, 21, 22, 23, 24], dtype=int32)"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "A = tf.constant(numpy_A,shape=(2,3,4))\n",
        "B= tf.constant(numpy_A)\n",
        "A,B\n",
        "#A.ndim\n",
        "#B.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7Ixy83lOwkTY",
        "outputId": "6b660af8-8832-4327-fb0a-8799b59cdd13"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(2, 3, 4), dtype=int32, numpy=\n",
              " array([[[ 1,  2,  3,  4],\n",
              "         [ 5,  6,  7,  8],\n",
              "         [ 9, 10, 11, 12]],\n",
              " \n",
              "        [[13, 14, 15, 16],\n",
              "         [17, 18, 19, 20],\n",
              "         [21, 22, 23, 24]]], dtype=int32)>,\n",
              " <tf.Tensor: shape=(24,), dtype=int32, numpy=\n",
              " array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
              "        18, 19, 20, 21, 22, 23, 24], dtype=int32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Getting information from tensors\n",
        "\n",
        "When dealing with tensors you probably want to be aware of following attributes\n",
        "\n",
        "+ Shape\n",
        "+ Rank\n",
        "+ Axis or dimension\n",
        "+ Size"
      ],
      "metadata": {
        "id": "dpr9YKLS0YrW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "rank_4_tensor = tf.zeros(shape=[2,3,4,5])\n",
        "rank_4_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oR9C7DNdzgze",
        "outputId": "38652750-17fb-42ef-ce76-7309dd7d5142"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3, 4, 5), dtype=float32, numpy=\n",
              "array([[[[0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.]],\n",
              "\n",
              "        [[0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.]],\n",
              "\n",
              "        [[0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.]]],\n",
              "\n",
              "\n",
              "       [[[0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.]],\n",
              "\n",
              "        [[0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.]],\n",
              "\n",
              "        [[0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.],\n",
              "         [0., 0., 0., 0., 0.]]]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rank_4_tensor.shape,rank_4_tensor.ndim,tf.size(rank_4_tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OlLn0Dgs0ctN",
        "outputId": "8b7ab7e7-5079-4caf-f76d-37ffbd2e27ce"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorShape([2, 3, 4, 5]), 4, <tf.Tensor: shape=(), dtype=int32, numpy=120>)"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get various attributes of tensor\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 the tensor: \", tf.size(rank_4_tensor).numpy())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ErdUyvje2THl",
        "outputId": "b882f0e9-9d18-4883-a07c-3cfc7db2978d"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Datatype of every element:  <dtype: 'float32'>\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 the tensor:  120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### indexing tensors\n",
        "\n",
        "Tensors can be indexed just like Python lists."
      ],
      "metadata": {
        "id": "UOaz0TWA4MRR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# get the first 2 elements of each of our tensors\n",
        "rank_4_tensor[:2,:2,:2,:2]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N9Gb7pS13KYM",
        "outputId": "aca193b0-c5a4-4ed9-b50b-d5b68c0f6e08"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2, 2, 2), dtype=float32, numpy=\n",
              "array([[[[0., 0.],\n",
              "         [0., 0.]],\n",
              "\n",
              "        [[0., 0.],\n",
              "         [0., 0.]]],\n",
              "\n",
              "\n",
              "       [[[0., 0.],\n",
              "         [0., 0.]],\n",
              "\n",
              "        [[0., 0.],\n",
              "         [0., 0.]]]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# get the first element of each of our tensors except for final tensor\n",
        "rank_4_tensor[:1,:1,:,:1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VsHheU-E4Hsk",
        "outputId": "4d1bbebd-c54d-4478-9900-7a51de389134"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(1, 1, 4, 1), dtype=float32, numpy=\n",
              "array([[[[0.],\n",
              "         [0.],\n",
              "         [0.],\n",
              "         [0.]]]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Create a rank 2 tensor (2 dimensions)\n",
        "rank_2_tensor = tf.zeros(shape=[2,2])\n",
        "rank_2_tensor\n",
        "rank_2_tensor.shape,rank_2_tensor.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iuZXmTum4sAl",
        "outputId": "63c02884-9f76-4ab1-fefb-83726e458dfd"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorShape([2, 2]), 2)"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get last item of each row of rank 2 tensor\n",
        "rank_2_tensor[:,:-1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hsXkz7B65EkW",
        "outputId": "b859d80d-5070-4e00-8f23-2e78df2d777c"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 1), dtype=float32, numpy=\n",
              "array([[0.],\n",
              "       [0.]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Adding extra dimension to our tensor\n",
        "rank_3_tensor = rank_2_tensor[...,tf.newaxis]\n",
        "rank_3_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j1x3rDgb5dES",
        "outputId": "36f671c5-b3c5-4a46-8f25-586d44d5da57"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2, 1), dtype=float32, numpy=\n",
              "array([[[0.],\n",
              "        [0.]],\n",
              "\n",
              "       [[0.],\n",
              "        [0.]]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Alternative to tf.newaxis\n",
        "\n",
        "tf.expand_dims(rank_2_tensor,axis=-1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4D4ZWvrD52kf",
        "outputId": "ebc89305-991a-43a7-923e-5bae20176e68"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2, 1), dtype=float32, numpy=\n",
              "array([[[0.],\n",
              "        [0.]],\n",
              "\n",
              "       [[0.],\n",
              "        [0.]]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.expand_dims(rank_2_tensor,axis=0) # expand the 0th axis"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WxOHgIIP6MTp",
        "outputId": "7b903c93-3b7e-4086-e58e-f92c520feab7"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(1, 2, 2), dtype=float32, numpy=\n",
              "array([[[0., 0.],\n",
              "        [0., 0.]]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Manipulating tensors(tensor operations)\n",
        "\n",
        "***Basic Operations ***\n",
        "\n",
        "+,-, *, /"
      ],
      "metadata": {
        "id": "9ago4ggta1Ez"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = tf.constant([[10,7],[3,4]])\n",
        "tensor += 10\n",
        "tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dJBw2WCv6Ysh",
        "outputId": "76b94ddd-3942-4bac-8d00-a7a5f8f2e420"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[20, 17],\n",
              "       [13, 14]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor -= 10\n",
        "tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GJ7MmvU8bB1t",
        "outputId": "9aec9647-4380-470f-ca06-c7887719b1b9"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[10,  7],\n",
              "       [ 3,  4]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor *=10\n",
        "tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0d0rtwKobXKP",
        "outputId": "75ea77a8-b65f-4b3e-fc63-f5eb0a905fc5"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[100,  70],\n",
              "       [ 30,  40]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor /=10"
      ],
      "metadata": {
        "id": "4_EPqpnNbYpK"
      },
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Matrix multiplication**\n",
        "\n",
        "In machine learning matrix multiplications are one of the most common operations performed on tensors\n",
        "\n",
        "There are two rules or tensors need to fulfil if we're going to mutiply them:\n",
        "\n",
        "1. The inner dimensions must match\n",
        "2. The resulting matrix has the shape of inner dimensions\n",
        "\n"
      ],
      "metadata": {
        "id": "RXiwo4BDcRMq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Matrix multiplication in tensorflow\n",
        "print(tensor)\n",
        "tf.matmul(tensor,tensor)"
      ],
      "metadata": {
        "id": "LGn0xq8PbbVN",
        "outputId": "18ca541e-62bf-4028-eec7-f824a03fc12c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[10.  7.]\n",
            " [ 3.  4.]], shape=(2, 2), dtype=float64)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=float64, numpy=\n",
              "array([[121.,  98.],\n",
              "       [ 42.,  37.]])>"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor * tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yZEI50GLcfcQ",
        "outputId": "42d4a7d5-c698-4237-d134-4406cb9561ed"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=float64, numpy=\n",
              "array([[100.,  49.],\n",
              "       [  9.,  16.]])>"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# matrix multiplication with python operator \"@\"\n",
        "tensor @ tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OD8OwT96bL1r",
        "outputId": "b15e3b7d-2cec-42c7-b68f-e628436df5b5"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=float64, numpy=\n",
              "array([[121.,  98.],\n",
              "       [ 42.,  37.]])>"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pHvAUKvCcWg3",
        "outputId": "d8f232a4-2e43-4b40-cbc9-ca421ec7f54a"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "TensorShape([2, 2])"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensor of 2 * 3\n",
        "X = tf.constant([[1,2,3],[4,5,6]])\n",
        "# Another 3 * 2 tensor\n",
        "Y = tf.constant([[7,8],[9,10],[11,12]])\n",
        "X,Y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Naq4wIiLcy_c",
        "outputId": "3d9b7fd6-85bb-410b-af7c-6b8b8e8681cd"
      },
      "execution_count": 42,
      "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)>,\n",
              " <tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              " array([[ 7,  8],\n",
              "        [ 9, 10],\n",
              "        [11, 12]], dtype=int32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "  # Multiply tensors of same shape\n",
        "tf.matmul(X,Y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Moj19v9jdaCJ",
        "outputId": "3580f635-082b-41ac-f53d-8384c881a99b"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[ 58,  64],\n",
              "       [139, 154]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# reshape tensor\n",
        "X = tf.constant([[1,2],[3,4],[5,6]])\n",
        "reshaped_y = tf.reshape(Y,shape=(2,3))\n"
      ],
      "metadata": {
        "id": "kFSZQQUKdlF3"
      },
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "X"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7sDKC8N0m9xQ",
        "outputId": "624f8fb4-8efa-458e-8b51-20737e83a1a2"
      },
      "execution_count": 45,
      "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": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "reshaped_y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V1YuLyOHm3I4",
        "outputId": "808b6e4f-ebdf-43fc-fa58-3e3e22f5ca3a"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 3), dtype=int32, numpy=\n",
              "array([[ 7,  8,  9],\n",
              "       [10, 11, 12]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X @ reshaped_y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LlQq7goVmOft",
        "outputId": "8f6f3425-6269-4b92-cb43-bcc58206e148"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              "array([[ 27,  30,  33],\n",
              "       [ 61,  68,  75],\n",
              "       [ 95, 106, 117]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Resource** info and example of resource multiplication https://www.mathsisfun.com/algebra/matrix-multiplying.html"
      ],
      "metadata": {
        "id": "UsmNr4peebm8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.matmul(X,reshaped_y)"
      ],
      "metadata": {
        "id": "V46l7vOjecJ2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b9524880-2063-4e8b-cecc-03430d86ba94"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              "array([[ 27,  30,  33],\n",
              "       [ 61,  68,  75],\n",
              "       [ 95, 106, 117]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Can do same with transpose\n",
        "X, tf.transpose(X),tf.reshape(X,shape=(2,3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fAU7RklVnVm5",
        "outputId": "92aaa4b6-2cb9-4618-ac3d-0a8a20f86906"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              " array([[1, 2],\n",
              "        [3, 4],\n",
              "        [5, 6]], dtype=int32)>,\n",
              " <tf.Tensor: shape=(2, 3), dtype=int32, numpy=\n",
              " array([[1, 3, 5],\n",
              "        [2, 4, 6]], dtype=int32)>,\n",
              " <tf.Tensor: shape=(2, 3), dtype=int32, numpy=\n",
              " array([[1, 2, 3],\n",
              "        [4, 5, 6]], dtype=int32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Try matrix multiplication with transpose rather than reshape\n",
        "tf.matmul(tf.transpose(X),Y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AuMqktQwnjvR",
        "outputId": "1b562797-485d-4fef-f1e7-1fbb13b80cf9"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[ 89,  98],\n",
              "       [116, 128]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**The dot product**\n",
        "\n",
        "Matrix multiplication is also known as the dot product.\n",
        "\n",
        "You can perform matrix multiplication using:\n",
        "* `tf.matmul()`\n",
        "* `tf.tensordot`"
      ],
      "metadata": {
        "id": "pf93zwaUTSaG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Perform the dot product on X and Y (requires X & Y to be transposed)\n",
        "tf.tensordot(tf.transpose(X),Y,axes=1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DOXzCTOioFCH",
        "outputId": "cc5b737a-36d6-4165-8186-dacdfc041baf"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[ 89,  98],\n",
              "       [116, 128]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Perform matrix multiplication between X and y(transposed)\n",
        "tf.matmul(X,tf.transpose(Y))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4cNyo8gCVX6Y",
        "outputId": "7e65d43c-3ce8-44c9-d2b9-bc812834c07a"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "execute_result",
          "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)>"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Perform matrix multiplication between X and y(reshaped)\n"
      ],
      "metadata": {
        "id": "ReYYMrIkTQ7Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.matmul(X,tf.reshape(Y,shape=(2,3)))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2aUO0K2hV9VW",
        "outputId": "e71b4ce7-ce3c-4e46-ee4c-a87ae28f2a37"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 3), dtype=int32, numpy=\n",
              "array([[ 27,  30,  33],\n",
              "       [ 61,  68,  75],\n",
              "       [ 95, 106, 117]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Check tthe values of Y, reshape and transpose\n",
        "print(\"Normal Y: \")\n",
        "print(Y,\"\\n\")\n",
        "\n",
        "print(\"Y reshaped to (2,3): \")\n",
        "print(tf.reshape(Y,shape=(2,3)), \"\\n\")\n",
        "\n",
        "print(\"Y transposed: \")\n",
        "print(tf.transpose(Y))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cq1KRO02WBHE",
        "outputId": "9d11171d-abda-4ef2-dbc4-50e9d64ef27f"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Normal Y: \n",
            "tf.Tensor(\n",
            "[[ 7  8]\n",
            " [ 9 10]\n",
            " [11 12]], shape=(3, 2), dtype=int32) \n",
            "\n",
            "Y reshaped to (2,3): \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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.matmul(X,tf.transpose(Y))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TI-jxV8WWtU3",
        "outputId": "a6d79863-ec5f-4770-efec-82f1b16280ea"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "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)>"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Generally when performing multiplication on two tensors generally you would transpose(rather than reshape) to satisfy the multiplacation rules"
      ],
      "metadata": {
        "id": "56B3l8gjawVO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Changing the datatype of a tensor"
      ],
      "metadata": {
        "id": "qzTMdkaZbHXE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.__version__"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "oiwJnLjrMcbY",
        "outputId": "8b8847d3-64cd-48cc-c842-1053890ec2c7"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2.15.0'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a new tensor with default datatype(float32) - defaults to whatever type is inside tenor\n",
        "# Default is 32 bit precision\n",
        "B=tf.constant([1.7,10])\n",
        "B, B.dtype\n"
      ],
      "metadata": {
        "id": "z0JNyuA2ajac",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7ce9d9e5-4fd0-45a0-b606-bff7cd0b494a"
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(2,), dtype=float32, numpy=array([ 1.7, 10. ], dtype=float32)>,\n",
              " tf.float32)"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "C=tf.constant([1,10])\n",
        "C.dtype\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MIhgbpYEMSrY",
        "outputId": "d5c6ce35-fa5f-4ab5-eb96-f230967c8979"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tf.int32"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Change from float 32 to float16(reduced precision)\n",
        "D = tf.cast(B,dtype=tf.float16)\n",
        "D, D.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wlwwiJwvMipJ",
        "outputId": "1a2f7def-91e7-4c31-a9a7-60e5a372673f"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(2,), dtype=float16, numpy=array([ 1.7, 10. ], dtype=float16)>,\n",
              " tf.float16)"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Change from int32 to float32\n",
        "E = tf.cast(C, dtype=tf.float32)\n",
        "E, E.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7UAA95JkNUfO",
        "outputId": "49a99c61-19bc-4b43-9ed8-72d1918e70d4"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(2,), dtype=float32, numpy=array([ 1., 10.], dtype=float32)>,\n",
              " tf.float32)"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "E_float_16 = tf.cast(E,dtype=tf.float16)\n",
        "E_float_16,E_float_16.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hvXseRaqN8fZ",
        "outputId": "22a576b1-8985-47dc-af3e-04e4382258f8"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(2,), dtype=float16, numpy=array([ 1., 10.], dtype=float16)>,\n",
              " tf.float16)"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Aggregating tensors\n",
        "Aggregating tensors = combining tensors to form a new tensor which is made up of the combined tensors"
      ],
      "metadata": {
        "id": "QrTekhItQLon"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the absolute values\n",
        "D = tf.constant([-7,-10])\n",
        "D"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oPnLju_ZOG19",
        "outputId": "acf713fb-416d-4553-8ca5-44b6d3d6aeae"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([ -7, -10], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the absolute values\n",
        "tf.abs(D)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8p6rQsGGOVxX",
        "outputId": "9e92d3e9-c45f-43bd-ce94-e5cb5ad84c4d"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([ 7, 10], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's go through following forms of aggregation:\n",
        "* Get the minimum\n",
        "* Get the maximum\n",
        "* Get the mean\n",
        "* Get the sum\n"
      ],
      "metadata": {
        "id": "pG26qITBQ0Gc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "new_tensor = tf.constant([5.,6.,7.,8.])\n",
        "tf.math.reduce_min(new_tensor)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y9r6JZxHQon8",
        "outputId": "eee8571b-d094-4076-8939-762a0c2228bb"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=5.0>"
            ]
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.math.reduce_max(new_tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hlT4-ou3RNGE",
        "outputId": "753eb563-8514-4b49-828b-465925b31c48"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=8.0>"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.math.reduce_mean(new_tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yqEx8F1xRfE-",
        "outputId": "f483ed8c-6879-4a15-ccf0-d3ad11f4d66d"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=6.5>"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.math.reduce_sum(new_tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XZohCQljRgqG",
        "outputId": "1d6c5dc7-5f52-469a-c256-6a580845e9cb"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=26.0>"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Exercise:** With what we've just learned, find the variance and standard deviation of the tensor"
      ],
      "metadata": {
        "id": "Eg5Cr2WKR3Ip"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.math.reduce_variance(new_tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c37zYor4Rjkl",
        "outputId": "27bdbdee-af06-4675-f4b3-a3457a13cff9"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=1.25>"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.math.reduce_std(new_tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iyX3wa5aSLMc",
        "outputId": "8291c0e7-20da-4f3b-d990-0f08066fae42"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=1.1180339>"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Find the positional maximum and minimum of tensor"
      ],
      "metadata": {
        "id": "LXq-tMGFTFEv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a new tensor for finding positional min and max\n",
        "tf.random.set_seed(42)\n",
        "F= tf.random.uniform(shape=[50])\n",
        "F"
      ],
      "metadata": {
        "id": "knFqIBS2SEUE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f94a1de9-8ce3-4af3-b829-dfdaa5d70434"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(50,), dtype=float32, numpy=\n",
              "array([0.6645621 , 0.44100678, 0.3528825 , 0.46448255, 0.03366041,\n",
              "       0.68467236, 0.74011743, 0.8724445 , 0.22632635, 0.22319686,\n",
              "       0.3103881 , 0.7223358 , 0.13318717, 0.5480639 , 0.5746088 ,\n",
              "       0.8996835 , 0.00946367, 0.5212307 , 0.6345445 , 0.1993283 ,\n",
              "       0.72942245, 0.54583454, 0.10756552, 0.6767061 , 0.6602763 ,\n",
              "       0.33695042, 0.60141766, 0.21062577, 0.8527372 , 0.44062173,\n",
              "       0.9485276 , 0.23752594, 0.81179297, 0.5263394 , 0.494308  ,\n",
              "       0.21612847, 0.8457197 , 0.8718841 , 0.3083862 , 0.6868038 ,\n",
              "       0.23764038, 0.7817228 , 0.9671384 , 0.06870162, 0.79873943,\n",
              "       0.66028714, 0.5871513 , 0.16461694, 0.7381023 , 0.32054043],\n",
              "      dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find positional maximum\n",
        "tf.argmax(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XX_HDv_-0sO2",
        "outputId": "0eea2e2f-2587-436e-fe12-8b2bd2cb6c6a"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=42>"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.argmax(F)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MtZch__L058_",
        "outputId": "22a84172-ef31-45f9-c7ac-27eac0770d82"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "42"
            ]
          },
          "metadata": {},
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "F[tf.argmax(F)]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HXKBT3bP09Es",
        "outputId": "b733df4a-b083-4cd2-b547-88cd8bab9b18"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=0.9671384>"
            ]
          },
          "metadata": {},
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.reduce_max(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XcVHNzu61HSv",
        "outputId": "d6e8d14f-f332-40f3-9c5e-990d67b7e7c8"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=0.9671384>"
            ]
          },
          "metadata": {},
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# check for equality\n",
        "F[tf.argmax(F)] == tf.reduce_max(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3P9iQr1U1Qb8",
        "outputId": "d24a7b4b-4df8-4ae6-cde8-81636e841aa5"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=bool, numpy=True>"
            ]
          },
          "metadata": {},
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find positional minimum\n",
        "tf.argmin(F)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Osu551CZ1WxC",
        "outputId": "1e6fac7c-fd32-4de7-bfaf-f6c296809a9c"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int64, numpy=16>"
            ]
          },
          "metadata": {},
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "F[tf.argmin(F)]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-TkOjKzh1jyH",
        "outputId": "5cd59e87-ed6b-4612-bee6-08083af181fd"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=0.009463668>"
            ]
          },
          "metadata": {},
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Squeezing a tensor(removing all single dimensions)\n",
        "\n",
        "Squeeze gets rid of unnecessary extra dimensions of size one"
      ],
      "metadata": {
        "id": "vYw6Qxb421go"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## Create a tensor to get started\n",
        "tf.random.set_seed(42)\n",
        "G = tf.constant(tf.random.uniform(shape=[50]),shape=(1,1,1,1,50))\n",
        "G"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-CxVUEbE1lYg",
        "outputId": "7da4072e-dac7-404c-d1a9-c5fa5745e872"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(1, 1, 1, 1, 50), dtype=float32, numpy=\n",
              "array([[[[[0.6645621 , 0.44100678, 0.3528825 , 0.46448255, 0.03366041,\n",
              "           0.68467236, 0.74011743, 0.8724445 , 0.22632635, 0.22319686,\n",
              "           0.3103881 , 0.7223358 , 0.13318717, 0.5480639 , 0.5746088 ,\n",
              "           0.8996835 , 0.00946367, 0.5212307 , 0.6345445 , 0.1993283 ,\n",
              "           0.72942245, 0.54583454, 0.10756552, 0.6767061 , 0.6602763 ,\n",
              "           0.33695042, 0.60141766, 0.21062577, 0.8527372 , 0.44062173,\n",
              "           0.9485276 , 0.23752594, 0.81179297, 0.5263394 , 0.494308  ,\n",
              "           0.21612847, 0.8457197 , 0.8718841 , 0.3083862 , 0.6868038 ,\n",
              "           0.23764038, 0.7817228 , 0.9671384 , 0.06870162, 0.79873943,\n",
              "           0.66028714, 0.5871513 , 0.16461694, 0.7381023 , 0.32054043]]]]],\n",
              "      dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 78
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "G.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PXo3fOZA2-8R",
        "outputId": "f3c8e121-3e4b-48a0-f763-f12e2e08b9b6"
      },
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "TensorShape([1, 1, 1, 1, 50])"
            ]
          },
          "metadata": {},
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "G_squeezed = tf.squeeze(G)\n",
        "G_squeezed,G_squeezed.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CvUC14u33Hzp",
        "outputId": "f79dcd53-612e-4640-cd7d-4ea448af391d"
      },
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(50,), dtype=float32, numpy=\n",
              " array([0.6645621 , 0.44100678, 0.3528825 , 0.46448255, 0.03366041,\n",
              "        0.68467236, 0.74011743, 0.8724445 , 0.22632635, 0.22319686,\n",
              "        0.3103881 , 0.7223358 , 0.13318717, 0.5480639 , 0.5746088 ,\n",
              "        0.8996835 , 0.00946367, 0.5212307 , 0.6345445 , 0.1993283 ,\n",
              "        0.72942245, 0.54583454, 0.10756552, 0.6767061 , 0.6602763 ,\n",
              "        0.33695042, 0.60141766, 0.21062577, 0.8527372 , 0.44062173,\n",
              "        0.9485276 , 0.23752594, 0.81179297, 0.5263394 , 0.494308  ,\n",
              "        0.21612847, 0.8457197 , 0.8718841 , 0.3083862 , 0.6868038 ,\n",
              "        0.23764038, 0.7817228 , 0.9671384 , 0.06870162, 0.79873943,\n",
              "        0.66028714, 0.5871513 , 0.16461694, 0.7381023 , 0.32054043],\n",
              "       dtype=float32)>,\n",
              " TensorShape([50]))"
            ]
          },
          "metadata": {},
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### One hot encoding tensors"
      ],
      "metadata": {
        "id": "q8mmBLiz3kid"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a list of indicies\n",
        "some_list = [0,1,2,3] # could be any set of values eg: red, green, blue, and purple\n",
        "tf.one_hot(some_list,4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WVsjoim_3Uau",
        "outputId": "7c3d1878-977f-46fe-e5b4-908b71ac450c"
      },
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "execute_result",
          "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)>"
            ]
          },
          "metadata": {},
          "execution_count": 81
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Specify custom values for one hot encoding\n",
        "tf.one_hot(some_list,depth=4,on_value=\"I love deep-learning\", off_value = \"I also like to dance\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "clEZHk_p4WAI",
        "outputId": "ea75c581-6f57-4cf3-e8e0-b4524fd3a7cc"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(4, 4), dtype=string, numpy=\n",
              "array([[b'I love deep-learning', b'I also like to dance',\n",
              "        b'I also like to dance', b'I also like to dance'],\n",
              "       [b'I also like to dance', b'I love deep-learning',\n",
              "        b'I also like to dance', b'I also like to dance'],\n",
              "       [b'I also like to dance', b'I also like to dance',\n",
              "        b'I love deep-learning', b'I also like to dance'],\n",
              "       [b'I also like to dance', b'I also like to dance',\n",
              "        b'I also like to dance', b'I love deep-learning']], dtype=object)>"
            ]
          },
          "metadata": {},
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Squaring, log, and square root"
      ],
      "metadata": {
        "id": "7QSIuF9T6tgp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create new tensor\n",
        "H = tf.range(1,10)\n",
        "H"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mpyoon766QeW",
        "outputId": "e113f426-3dac-43d6-fc3b-195fc66afa73"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(9,), dtype=int32, numpy=array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.square(H)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BOsGYnhK6xiI",
        "outputId": "e5108fc8-95ec-45b9-838f-34e97d73750a"
      },
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(9,), dtype=int32, numpy=array([ 1,  4,  9, 16, 25, 36, 49, 64, 81], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# find square root\n",
        "tf.sqrt(tf.cast(H,dtype=tf.float32))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1bXtr3At6ynX",
        "outputId": "9f229389-3164-4c5a-ab69-5381e1d0b055"
      },
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "execute_result",
          "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)>"
            ]
          },
          "metadata": {},
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the log\n",
        "tf.math.log(tf.cast(H,dtype=tf.float32))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9jGHSfhb645z",
        "outputId": "aa813c00-4892-4a88-d7e0-f66416fe200b"
      },
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(9,), dtype=float32, numpy=\n",
              "array([0.       , 0.6931472, 1.0986123, 1.3862944, 1.609438 , 1.7917595,\n",
              "       1.9459102, 2.0794415, 2.1972246], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Tensors in numpy\n",
        "Tensorflow interacts beautifully with numpy arrays."
      ],
      "metadata": {
        "id": "7f4Z3iKz9Fa8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tensor directly from numpy arrays\n",
        "J = tf.constant(np.array([3.,7.,10.]))\n",
        "J"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L78DvW8a7Xi5",
        "outputId": "d5dff9b2-58e8-42fa-e95c-4498cc1fcebe"
      },
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3,), dtype=float64, numpy=array([ 3.,  7., 10.])>"
            ]
          },
          "metadata": {},
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert our tensor back to numpy array\n",
        "np.array(J), type(np.array(J))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TYnLC_vu9Z0G",
        "outputId": "3b2f48b0-eb0b-4458-cc78-9c2ec7c436a2"
      },
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([ 3.,  7., 10.]), numpy.ndarray)"
            ]
          },
          "metadata": {},
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert tensor J to numpy array\n",
        "J.numpy(),type(J.numpy())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eg7X1L4O9gm9",
        "outputId": "acb2321b-9136-4bf5-dea7-90e9c1dcbf91"
      },
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([ 3.,  7., 10.]), numpy.ndarray)"
            ]
          },
          "metadata": {},
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# The default types of each slightly differ\n",
        "numpy_J = tf.constant(np.array([3.,7.,10.]))\n",
        "tensor_J = tf.constant([3.,7.,10.])\n",
        "# check the datatype of each\n",
        "numpy_J.dtype,tensor_J.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YAUREGuL9yfW",
        "outputId": "1cbd9b5e-8a1e-48da-dd40-9bed513939fe"
      },
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tf.float64, tf.float32)"
            ]
          },
          "metadata": {},
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Finding access to GPUS"
      ],
      "metadata": {
        "id": "ifNukqkv_4OI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.config.list_physical_devices(\"GPU\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DJOU1f1g92MU",
        "outputId": "116240b0-3121-4fee-b257-2fc90f8d9020"
      },
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]"
            ]
          },
          "metadata": {},
          "execution_count": 91
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!nvidia-smi"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JyJN2RPCACZx",
        "outputId": "6934771a-2ab2-439e-ec3d-df6cea8d644d"
      },
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sun Jan 14 17:25:39 2024       \n",
            "+---------------------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 535.104.05             Driver Version: 535.104.05   CUDA Version: 12.2     |\n",
            "|-----------------------------------------+----------------------+----------------------+\n",
            "| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                                         |                      |               MIG M. |\n",
            "|=========================================+======================+======================|\n",
            "|   0  Tesla T4                       Off | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   60C    P0              29W /  70W |    117MiB / 15360MiB |      0%      Default |\n",
            "|                                         |                      |                  N/A |\n",
            "+-----------------------------------------+----------------------+----------------------+\n",
            "                                                                                         \n",
            "+---------------------------------------------------------------------------------------+\n",
            "| Processes:                                                                            |\n",
            "|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |\n",
            "|        ID   ID                                                             Usage      |\n",
            "|=======================================================================================|\n",
            "+---------------------------------------------------------------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**NOTE:** If you have access to cuda-enabled GPU, tensorflow will automatically use it whenever possible"
      ],
      "metadata": {
        "id": "boA4hH_eAzie"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "CNU9G9j8AfMb"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}