00_tensorflow_fundamentals.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "00_tensorflow_fundamentals.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPh51N0KqUroZpMAQfxdHyq",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AndreiRosu/tensorflow/blob/main/00_tensorflow_fundamentals.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# In this notebook we are going to cover some of the most fundamental concepts of tensors using TensorFlow\n",
        "\n",
        "More specifically, we're going to cover:\n",
        "* Introduction to tensors\n",
        "* Getting information from tensors\n",
        "* Manipulation tensors\n",
        "* Tensors & NumPy\n",
        "* Using @tf.function (a way to speed up your regular Python functions)\n",
        "* Using GPUs with TensorFlow (or TPUs)\n",
        "* Exercises"
      ],
      "metadata": {
        "id": "wGIIh32Pluuq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Introduction to tensors"
      ],
      "metadata": {
        "id": "DvuuU-G9nQPV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        ""
      ],
      "metadata": {
        "id": "9zhIgIY43Z1-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import TensorFlow\n",
        "import tensorflow as tf\n",
        "print(tf.__version__)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nO88bobinVOz",
        "outputId": "b696cc06-5ac7-48c1-956a-df401949ce23"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.8.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": "t---GQhLn8dG",
        "outputId": "c16fd616-3705-4d0f-b922-2d4b7e233f79"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=int32, numpy=7>"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check the number of dimensions of a tensor (ndim stands for number of dimensions)\n",
        "scalar.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "94PlXKZ4o3Nd",
        "outputId": "8c8faf8f-5e70-4bbd-a7be-29055b5023e5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a vector\n",
        "vector = tf.constant([10, 10])\n",
        "vector"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mhx_6WfUpMPw",
        "outputId": "b0cc709a-391b-4f97-db50-a81284e44b44"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([10, 10], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check the dimension of our vector\n",
        "vector.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7YEKu5o6p6qQ",
        "outputId": "9f0cea13-5826-4910-cf91-4996913e161b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a matrix (has more than one dimension)\n",
        "matrix = tf.constant([[10, 7], [7, 10]])\n",
        "matrix"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "STopQ1qzqZoe",
        "outputId": "70cdb7f9-b6a5-45f3-e52c-aa50b7ef7601"
      },
      "execution_count": null,
      "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": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check the dimension of our matrix\n",
        "matrix.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xbETyGThq1zx",
        "outputId": "6381b4b7-1abb-4fea-f79b-38f0e59bbb3c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create another matrix\n",
        "another_matrix = tf.constant([\n",
        "                              [10., 7.], \n",
        "                              [3., 2.], \n",
        "                              [8., 9.]], \n",
        "                             dtype=tf.float16) # specify the data type with dtype parameter\n",
        "another_matrix"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kgDp3g3BsZjJ",
        "outputId": "72e988d0-fbb1-44c9-98ea-90474014673c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=float16, numpy=\n",
              "array([[10.,  7.],\n",
              "       [ 3.,  2.],\n",
              "       [ 8.,  9.]], dtype=float16)>"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's create a tensor\n",
        "tensor = tf.constant([\n",
        "                      [\n",
        "                       [1, 2, 3],\n",
        "                       [4, 5, 6]\n",
        "                      ],\n",
        "                      [\n",
        "                       [7, 8, 9],\n",
        "                       [10, 11, 12]\n",
        "                      ],\n",
        "                      [\n",
        "                       [13, 14, 15],\n",
        "                       [16, 17, 18]\n",
        "                      ]\n",
        "                    ])\n",
        "tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D2liFf6WvnqP",
        "outputId": "5aa3395f-b9d1-44e8-b2da-673f758b1fba"
      },
      "execution_count": null,
      "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": "code",
      "source": [
        "# Check the dimension of tensor\n",
        "tensor.ndim"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "blD84kkBwfjC",
        "outputId": "f8a0dcf5-9cd2-40e7-de80-8a2fa19d226d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "What we've created so far:\n",
        "* Scalar: a single number\n",
        "* Vector: a number with direction (eg: wind speed and direction)\n",
        "* Matrix: a two-dimensional array of numbers\n",
        "* Tensor: a n-dimensional array of numbers"
      ],
      "metadata": {
        "id": "uMD6S8s1w70e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating tensors with tf.Variable"
      ],
      "metadata": {
        "id": "HkSkUxyLCsjK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the same tensor with tf.Variable() as above\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": "OzhjJyxUCvnV",
        "outputId": "c47e0ee6-5630-4146-93eb-e6829846b2b3"
      },
      "execution_count": null,
      "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": "markdown",
      "source": [
        ""
      ],
      "metadata": {
        "id": "4l9FFBIZR00Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's try change one of the elements in out changeable_tensor\n",
        "# changeable_tensor[0] = 7;"
      ],
      "metadata": {
        "id": "4_wpP273EIee"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# How about we try .assign()\n",
        "changeable_tensor[0].assign(7)\n",
        "changeable_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "65TJN86EEYT7",
        "outputId": "50c08d92-a1a6-4706-87a2-2974ca29ca6a"
      },
      "execution_count": null,
      "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": [
        "# Let's try change our unchangeable tensor\n",
        "# unchangeable_tensor[0].assign(7)"
      ],
      "metadata": {
        "id": "7FOEl_AIEsaR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating random tensors\n",
        "Random tensors are tensors of some arbitrary size which contain random numbers."
      ],
      "metadata": {
        "id": "1SRSH4BYR6mR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create two random, but the same tensors\n",
        "random_1 = tf.random.Generator.from_seed(42) # set seed for reproducibility\n",
        "random_1 = random_1.normal(shape=(3, 2))\n",
        "random_2 = tf.random.Generator.from_seed(42)\n",
        "random_2 = random_2.normal(shape=(3, 2))\n",
        "random_1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SEhFWd5AR86U",
        "outputId": "4680be2b-6b06-498e-b267-59b27fde00f4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
              "array([[-0.7565803 , -0.06854702],\n",
              "       [ 0.07595026, -1.2573844 ],\n",
              "       [-0.23193763, -1.8107855 ]], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Shuffle the order of elements in a tensor"
      ],
      "metadata": {
        "id": "6arPgY9B67jx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Shuffle a tensor (valuable for when you want to shuffle your data so the inherent order doesn't affect learning)\n",
        "not_shuffled = tf.constant([[10, 7], [3, 4], [2, 5]])\n",
        "not_shuffled.ndim\n",
        "\n",
        "# Shuffle our non-shuffled tensor\n",
        "tf.random.shuffle(not_shuffled)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "COqxvm5v69_U",
        "outputId": "44705452-b156-45eb-d11a-3c0456e07f5c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              "array([[ 3,  4],\n",
              "       [ 2,  5],\n",
              "       [10,  7]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Turn NumPy arrays into tensors\n",
        "The main difference between NumPy arrays and TensorFlow tensors is that tensors can be run on GPU (much faster for numerical computations)"
      ],
      "metadata": {
        "id": "eU3Q42vKDOwE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# You can also turn NumPy arrays into tensors\n",
        "import numpy as np\n",
        "numpy_A = np.arange(1, 25, dtype=np.int32) # create a NumPy array between 1 and 25\n",
        "numpy_A"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cOvGjr6uDRWJ",
        "outputId": "26287441-21cf-481a-e380-c0f3fe621733"
      },
      "execution_count": null,
      "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": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "A = tf.constant(numpy_A)\n",
        "A"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3r0EwO3UELCY",
        "outputId": "9fb80d02-a780-4019-a8cc-4c42219f0a9e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<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": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Indexing tensors\n",
        "Tensors can be indexed just like Python lists"
      ],
      "metadata": {
        "id": "lHdZfBvGAUQz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the first two elements of each dimension\n",
        "zero_tensor = tf.zeros(shape=(2, 3, 4, 5));\n",
        "zero_tensor, zero_tensor[:2, :2]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vV5Em2WjAV9f",
        "outputId": "98841e7c-717a-4443-87c2-70a51b3424ad"
      },
      "execution_count": null,
      "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)>,\n",
              " <tf.Tensor: shape=(2, 2, 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",
              " \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": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the first element from each dimension except the final one\n",
        "zero_tensor[:1, :1, :, :1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aT6UUO4ADBB8",
        "outputId": "a2b47de0-4b2e-49dc-81d4-9b7a332c7e0a"
      },
      "execution_count": null,
      "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": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a rank two tensor (two dimensions)\n",
        "rank_2_tensor = tf.constant([[10, 7], [3, 4]])\n",
        "rank_2_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yQn2sR6SELWm",
        "outputId": "d634bb55-b535-4c88-e39b-11e992cd5c5e"
      },
      "execution_count": null,
      "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": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the last item of each row of our tensor\n",
        "rank_2_tensor[:, -1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F7ptIXYJEyyv",
        "outputId": "09936d67-5eed-42bf-c5b4-7eaf07ca8971"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2,), dtype=int32, numpy=array([7, 4], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Add in extra dimension to our rank two tensor\n",
        "#rank_3_tensor = rank_2_tensor[..., tf.newaxis]\n",
        "#rank_3_tensor\n",
        "rank_1_tensor = tf.constant([10, 7])\n",
        "new_rank_1_tensor = rank_1_tensor[..., tf.newaxis]\n",
        "rank_1_tensor, new_rank_1_tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mYqV6UsuF3b1",
        "outputId": "c02316dd-eced-4980-8e34-979120bb8232"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(2,), dtype=int32, numpy=array([10,  7], dtype=int32)>,\n",
              " <tf.Tensor: shape=(2, 1), dtype=int32, numpy=\n",
              " array([[10],\n",
              "        [ 7]], dtype=int32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Manipulation tensors (tensor operations)\n",
        "**Basic operations**"
      ],
      "metadata": {
        "id": "yS8ITbKCD5oQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# You can add values to a tensor using the addition operator\n",
        "tensor = tf.constant([[10, 7], [3, 4]])\n",
        "tensor + 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LlYY-GeUD8vy",
        "outputId": "2fccd015-ddde-436d-ca37-47ccd58ea6bf"
      },
      "execution_count": null,
      "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": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can use the tensor built-in function too\n",
        "tf.multiply(tensor, 10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u_IAj8U7KI8p",
        "outputId": "95c35b24-ce01-4ffe-88e3-13fa30429ff6"
      },
      "execution_count": null,
      "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": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Matrix multiplication**\n",
        "\n",
        "In machine learning, matrix multiplication is one of the most common tensor operations.  \n",
        "There are two rules our tensors (or matrices) need to fulfill if we're going to matrix multiply them:\n",
        "1. The inner dimensions must match\n",
        "2. The resulting matrix has the shape of the outer dimensions"
      ],
      "metadata": {
        "id": "b7pQUTH1LI8h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(tensor)\n",
        "tf.matmul(tensor, tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eu7uDjISMgKH",
        "outputId": "820362dd-8f7b-4a69-c49b-4029cc1ad529"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[10  7]\n",
            " [ 3  4]], shape=(2, 2), dtype=int32)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[121,  98],\n",
              "       [ 42,  37]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Matrix multiplication with Python operator \"@\"\n",
        "tensor @ tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5gy1EGXWOV2t",
        "outputId": "509cbd0c-7608-4ced-b1d7-7f399437ee2a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
              "array([[121,  98],\n",
              "       [ 42,  37]], dtype=int32)>"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a (3, 2) tensor\n",
        "X = tf.constant([[1, 2], [3, 4], [5, 6]])\n",
        "\n",
        "# Create another (3, 2) tensor\n",
        "Y = tf.constant([[7, 8], [9, 10], [11, 12]])\n",
        "\n",
        "X, Y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SPYDwjQHPQyJ",
        "outputId": "ded874db-8ad3-4a1c-976d-b3728ddf3e47"
      },
      "execution_count": null,
      "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)>, <tf.Tensor: shape=(3, 2), dtype=int32, numpy=\n",
              " array([[ 7,  8],\n",
              "        [ 9, 10],\n",
              "        [11, 12]], dtype=int32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Try to multiply tensors of the same shape\n",
        "# X @ Y"
      ],
      "metadata": {
        "id": "OL07qx1ZPUI5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's change the shape of Y\n",
        "tf.reshape(Y, shape=(2, 3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tIG8MiXsP52Z",
        "outputId": "488d0d8d-c9b0-4785-b577-1a55a43cb377"
      },
      "execution_count": null,
      "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": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Try to matrix multiply X by reshaped Y\n",
        "X @ tf.reshape(Y, shape=(2, 3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DryVP1B2Ugwo",
        "outputId": "3c373dcf-e0fc-4afc-c65a-46f0826458f5"
      },
      "execution_count": null,
      "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": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Transpose a tensor\n",
        "X, tf.transpose(X)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6RbR_6abV7LM",
        "outputId": "5ac0ed28-6390-40f3-d38b-c5c4a85740a1"
      },
      "execution_count": null,
      "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)>, <tf.Tensor: shape=(2, 3), dtype=int32, numpy=\n",
              " array([[1, 3, 5],\n",
              "        [2, 4, 6]], dtype=int32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**The dot product**\n",
        "\n",
        "Matrix multiplication is reffered to as the dot product.\n",
        "You can perform matrix multiplication using:\n",
        "* `tf.matmul()`\n",
        "* `tf.tensordot()`"
      ],
      "metadata": {
        "id": "Hl2z-qokdnLe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Perform the dot product on X and Y (requires X or Y to be transposed)\n",
        "tf.tensordot(tf.transpose(X), Y, axes=1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pp42fd8DdyO3",
        "outputId": "b072640b-8619-480a-923c-cd773c3fb3bf"
      },
      "execution_count": null,
      "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": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Perform matrix multiplication between X and Y (transposed)\n",
        "tf.matmul(X, tf.transpose(Y))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jx9FoOYKfI2V",
        "outputId": "aea2f443-14d5-41ba-ce82-b9d60df9ca76"
      },
      "execution_count": null,
      "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": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Perform matrix multiplication between X and Y (reshaped)\n",
        "tf.matmul(X, tf.reshape(Y, shape=(2, 3)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wDUCoM0kfc3s",
        "outputId": "d979a781-3516-43d2-e9d0-16242bdbd476"
      },
      "execution_count": null,
      "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": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check the values of Y, reshaped Y and transposed Y\n",
        "print(\"Normal Y:\")\n",
        "print(Y, \"\\n\")\n",
        "\n",
        "print(\"Y reshaped to (2, 3):\")\n",
        "print(tf.reshape(Y, (2, 3)), \"\\n\")\n",
        "\n",
        "print(\"Y transposed\")\n",
        "print(tf.transpose(Y))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6PE0_xRrgo8f",
        "outputId": "2a4ec1cf-a382-430c-8e05-0332f62dba7b"
      },
      "execution_count": null,
      "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"
          ]
        }
      ]
    }
  ]
}