7_fully_connected_nn/0_intro_to_tensorflow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<table style=\"border:none\">\n",
    "    <tr style=\"border:none\">\n",
    "    <th style=\"border:none\">\n",
    "        <a  href='https://colab.research.google.com/github/AmirMardan/ml_course/blob/main/7_fully_connected_nn/0_intro_to_tensorflow.ipynb'><img src='https://colab.research.google.com/assets/colab-badge.svg'></a>\n",
    "    </th>\n",
    "    <th style=\"border:none\">\n",
    "        <a  href='https://github1s.com/AmirMardan/ml_course/blob/main/7_fully_connected_nn/0_intro_to_tensorflow.ipynb'><img src='../imgs/open_vscode.svg' height=20px width=115px></a>\n",
    "    </th>\n",
    "    </tr>\n",
    "</table>\n",
    "</center>\n",
    "\n",
    "\n",
    "This notebook is created by <a href='https://amirmardan.github.io/'> Amir Mardan</a>. For any feedback or suggestion, please contact me via <a href=\"mailto:mardan.amir.h@gmail.com\">email</a>, (mardan.amir.h@gmail.com).\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='top'></a>\n",
    "# TensorFlow\n",
    "\n",
    "TensorFlow is a powerful open-source and end-to-end platform for building machine learning models and numerical modeling.\n",
    "Being end to end, we can perform all required steps of machine learning using TensorFlow.\n",
    "[Here](https://www.tensorflow.org/about/case-studies) are some projects that have been done using this package. \n",
    "\n",
    "This notebook will cover the following topics:\n",
    "\n",
    "- [1. Graph and Session](#graph)\n",
    "    - [1.1 Build and Perform a Graph](#build_graph)\n",
    "    - [1.2 Gradient in TensorFlow](#gradient)\n",
    "- [2. Tensor types in TensorFlow](#types)\n",
    "    - [2.1 Constant](#constant)\n",
    "    - [2.2 Variable](#variable)\n",
    "- [3. Tensor Manipulation](#tensor_manipulation)\n",
    "    - [3.1 Creating A Tensors](#create_array)\n",
    "    - [3.2 Creating Special Tensors](#special_array)\n",
    "    - [3.3 Shape Manipulation](#shape)\n",
    "    - [3.4 Slicing](#slicing)\n",
    "- [4. Operators](#Operations)\n",
    "    - [4.1 Basic Arithmetic Operators](#Arithmetic)\n",
    "    - [4.2 Comparison Operators](#Comparison)\n",
    "    - [4.3 Logical And Bitwise Operators](#Logical)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TensorFlow version: 2.6.0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "print(\"TensorFlow version:\", tf.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'm currently using `TensorFlow version: 2.8.0`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='graph'></a>\n",
    "## 1. Graph and Session\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TensorFlow is a way of representing computation without performing it until it's required. \n",
    "It's simple, we first define a <em>graph</em> in Python and we perform it when it's needed.\n",
    "\n",
    "- **step 1:** building a graph to represent the data flow.\n",
    "- **step 2:** running a <em>session</em> to execute the graph.\n",
    "\n",
    "<center>\n",
    "<img src='./img/graph_session.gif' height=400px>\n",
    "<br>\n",
    "<b>Figure 1</b> A sample computational graph in TensorFlow (TensorFlow website).\n",
    "</center>\n",
    "\n",
    "You should know that when you want to run a graph, you're not obliged to run the whole graph. \n",
    "There is significant flexibility that you can just run a part of a graph.\n",
    "\n",
    "All said, we should know that the explicitly defining of the graph and the session is removed for TensorFlow version 2.\n",
    "So, we use `tf.function` to create a graph, and then we can execute it like normal functions in Python. \n",
    "However, there are interesting differences that we see later.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='build_graph'></a>\n",
    "### 1.1 Build and Perform a Graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the first example, let's create the following graph.\n",
    "\n",
    "<center>\n",
    "<img src='./img/graph1.png' height=200px>\n",
    "</center>\n",
    "\n",
    "This graph is actually\n",
    "\\begin{equation}\n",
    "f(x,y) = x^2  y + y +2\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def f(x, y):\n",
    "    x_multi = tf.multiply(x, x, name='x_multiply')\n",
    "    x2y_multi = tf.multiply(x_multi, y, name='x2y_multiply')\n",
    "    y2_addition = tf.add(y, 2, name='y2_addition')\n",
    "    f = tf.add(x2y_multi, y2_addition)\n",
    "    return f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-24 20:02:52.908089: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-04-24 20:02:52.968600: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(), dtype=float32, numpy=52.0>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = tf.Variable(3.0)\n",
    "y = tf.Variable(5.0)\n",
    "\n",
    "result = f(x, y)\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the output of this function is a ***Tensor***. \n",
    "We can convert a Tensor to a NumPy array in two ways."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(52., dtype=float32)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "np.array(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='gradient'></a>\n",
    "### 1.2 Gradient in TensorFlow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The simplest definition for the gradient is that the gradient is the slope of a function in different directions.\n",
    "Calculating the gradient of a function is the core of training in machine learning or of any optimization problem.\n",
    "\n",
    "The gradient of the used equation with respect to y is\n",
    "\n",
    "\\begin{equation}\n",
    "\\frac{\\partial f(x,y)}{\\partial y} = x^2 + 1,\n",
    "\\end{equation}\n",
    "and TensorFlow allows us to compute it easily.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0\n"
     ]
    }
   ],
   "source": [
    "x = tf.Variable(3.0)\n",
    "y = tf.Variable(1.0)\n",
    "\n",
    "with tf.GradientTape() as g:\n",
    "    g.watch(y)\n",
    "    result = f(x, y)\n",
    "    dy = g.gradient(result, y)\n",
    "    \n",
    "print(dy.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same way, we can calculate the gradient of function with respect to both variables.\n",
    "\n",
    "\\begin{equation}\n",
    "\\begin{aligned}\n",
    "& \\frac{\\partial f(x,y)}{\\partial y} = x^2 + 1\\\\\n",
    "& \\frac{\\partial f(x,y)}{\\partial x} = 2xy\n",
    "\\end{aligned}\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "df/dx: 12.0, df/dy: 5.0\n"
     ]
    }
   ],
   "source": [
    "x = tf.Variable(2.)\n",
    "y = tf.Variable(3.0)\n",
    "\n",
    "with tf.GradientTape() as g:\n",
    "    g.watch([y, x])\n",
    "    result = f(x, y)\n",
    "    dx, dy = g.gradient(result, [x, y])\n",
    "    \n",
    "print(f\"df/dx: {dx.numpy()}, df/dy: {dy.numpy()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='types'></a>\n",
    "## 2. Tensor types in TensorFlow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you might have noticed, we defined the variables in the previous section using\n",
    "`tf.Variable()`.\n",
    "Hence, YES, we need to define the data we use with a structure that TensorFlow works with.\n",
    " \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='constant'></a>\n",
    "### 2.1 Constant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the name states, **Constant** is used for a constant value.\n",
    "Constants create a node that takes value and it's immutable. \n",
    "\n",
    "```Python\n",
    "tf.constant(\n",
    "    value, dtype=None, shape=None, name='Const'\n",
    ")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(1,), dtype=int32, numpy=array([1], dtype=int32)>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = tf.constant([1], name='first_constant')\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also define multi-dimension tensors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3,), dtype=float32, numpy=array([-1. ,  2. ,  3.9], dtype=float32)>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "VECTOR = tf.constant([-1, 2, 3.9], name='vector')\n",
    "\n",
    "VECTOR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 3), dtype=float32, numpy=\n",
       "array([[-1. ,  2. ,  3.9],\n",
       "       [ 3. , -1.2,  0. ]], dtype=float32)>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TWO_D = tf.constant([[-1, 2, 3.9],\n",
    "                     [3, -1.2, 0]], name='2d')\n",
    "\n",
    "TWO_D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2, 3), dtype=float32, numpy=\n",
       "array([[[-1. ,  2. ,  3.9],\n",
       "        [ 3. , -1.2,  0. ]],\n",
       "\n",
       "       [[ 0. ,  1. , -0.2],\n",
       "        [ 9. ,  3.2, 10. ]]], dtype=float32)>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "THREE_D = tf.constant([[[-1, 2, 3.9],\n",
    "                     [3, -1.2, 0]],\n",
    "                     [[0, 1, -0.2],\n",
    "                     [9, 3.2, 10]]], name='3d')\n",
    "\n",
    "THREE_D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='variable'></a>\n",
    "### 2.2 Variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned, the value of `constant`s doesn't change. \n",
    "So, for trainable variables, we need to use another type of data which is `Variable`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable '3d:0' shape=(2, 2, 3) dtype=float32, numpy=\n",
       "array([[[-1. ,  2. ,  3.9],\n",
       "        [ 3. , -1.2,  0. ]],\n",
       "\n",
       "       [[ 0. ,  1. , -0.2],\n",
       "        [ 9. ,  3.2, 10. ]]], dtype=float32)>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = tf.Variable([[[-1, 2, 3.9],\n",
    "                     [3, -1.2, 0]],\n",
    "                     [[0, 1, -0.2],\n",
    "                     [9, 3.2, 10]]], name='3d')\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2, 3), dtype=float32, numpy=\n",
       "array([[[-2. ,  4. ,  7.8],\n",
       "        [ 6. , -2.4,  0. ]],\n",
       "\n",
       "       [[ 0. ,  2. , -0.4],\n",
       "        [18. ,  6.4, 20. ]]], dtype=float32)>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with tf.GradientTape() as gtape:\n",
    "    y = x ** 2 + 10\n",
    "    \n",
    "gtape.gradient(y, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='tensor_manipulation'></a>\n",
    "## 3. Tensor Manipulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='create_array'></a>\n",
    "### 3.1 Creating A Tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous part, we learned two types of tensors, but in this part, we learn how to build a tensor.\n",
    "\n",
    "From the scratch, we can build a tensor using `tf.convert_to_tensor()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3,), dtype=int32, numpy=array([ 1,  3, -4], dtype=int32)>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.convert_to_tensor([1, 3, -4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 3), dtype=int32, numpy=\n",
       "array([[ 1,  3, -4],\n",
       "       [ 1,  3, -4]], dtype=int32)>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.convert_to_tensor([[1, 3, -4],\n",
    "                      [1, 3, -4]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also convert NumPy arrays to a Tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 3), dtype=float64, numpy=\n",
       "array([[0.36455596, 0.42898108, 0.95702029],\n",
       "       [0.21399316, 0.6813637 , 0.84888731]])>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.random.random((2, 3))\n",
    "\n",
    "tf.convert_to_tensor(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='special_array'></a>\n",
    "### 3.2 Creating Special Tensors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like NumPy and special arrays, TensorFlow allows us to create some special tensors more easily."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 3), dtype=float32, numpy=\n",
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.]], dtype=float32)>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a 1's tensor \n",
    "\n",
    "tf.ones(shape=(2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 3), dtype=float32, numpy=\n",
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.]], dtype=float32)>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a 0's tensor \n",
    "\n",
    "tf.zeros(shape=(2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 3), dtype=float32, numpy=\n",
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.]], dtype=float32)>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a identity tensor \n",
    "\n",
    "tf.eye(num_rows=2, num_columns=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 3), dtype=float32, numpy=\n",
       "array([[0.18388605, 0.6193502 , 0.73401904],\n",
       "       [0.9556105 , 0.02219713, 0.8945124 ]], dtype=float32)>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a random tensor with uniform distribution\n",
    "\n",
    "tf.random.uniform((2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 3), dtype=float32, numpy=\n",
       "array([[ 2.0382524 , -0.87904227, -0.26950473],\n",
       "       [ 0.16172941,  0.06466151,  0.380084  ]], dtype=float32)>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a random tensor with normal distribution\n",
    "\n",
    "tf.random.normal((2, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For repeatability, we can first create a seed for random values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[-0.1012345  -0.2744976   1.4204658 ]\n",
      " [ 1.2609464  -0.43640924 -1.9633987 ]], shape=(2, 3), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "random_tensor = tf.random.Generator.from_seed(2)\n",
    "\n",
    "\n",
    "rand_tensor = random_tensor.normal(shape=[2,3])\n",
    "print(rand_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also shuffle a tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(4, 5), dtype=float32, numpy=\n",
       "array([[ 0.2776104 , -0.52194345,  0.1151574 ,  1.3032064 ,  1.328346  ],\n",
       "       [-1.7339838 ,  0.90426886,  0.56855273, -1.2169818 ,  1.3774033 ],\n",
       "       [-0.4654596 , -0.51368004, -0.5356597 , -0.4981093 , -1.2551429 ],\n",
       "       [ 0.14776349, -1.0173497 , -1.0449705 ,  0.2018814 , -0.3598549 ]],\n",
       "      dtype=float32)>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b4_shuffle = random_tensor.normal(shape=(4,5))\n",
    "b4_shuffle\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(4, 5), dtype=float32, numpy=\n",
       "array([[ 0.14776349, -1.0173497 , -1.0449705 ,  0.2018814 , -0.3598549 ],\n",
       "       [-1.7339838 ,  0.90426886,  0.56855273, -1.2169818 ,  1.3774033 ],\n",
       "       [-0.4654596 , -0.51368004, -0.5356597 , -0.4981093 , -1.2551429 ],\n",
       "       [ 0.2776104 , -0.52194345,  0.1151574 ,  1.3032064 ,  1.328346  ]],\n",
       "      dtype=float32)>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shuffled = tf.random.shuffle(b4_shuffle)\n",
    "shuffled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='shape'></a>\n",
    "### 3.3 Shape Manipulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get information about the shape and number of dimensions of a tensor as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([4, 5])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shuffled.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shuffled.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also reshape a tensor using `tf.reshape(tensor, new_shape)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 10), dtype=float32, numpy=\n",
       "array([[ 0.14776349, -1.0173497 , -1.0449705 ,  0.2018814 , -0.3598549 ,\n",
       "        -1.7339838 ,  0.90426886,  0.56855273, -1.2169818 ,  1.3774033 ],\n",
       "       [-0.4654596 , -0.51368004, -0.5356597 , -0.4981093 , -1.2551429 ,\n",
       "         0.2776104 , -0.52194345,  0.1151574 ,  1.3032064 ,  1.328346  ]],\n",
       "      dtype=float32)>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.reshape(shuffled, [2, 10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same way, we can flatten a tensor as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(20,)\n"
     ]
    }
   ],
   "source": [
    "print(tf.reshape(shuffled, [-1]).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or presenting a tensor in form of a vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(20, 1)\n"
     ]
    }
   ],
   "source": [
    "print(tf.reshape(shuffled, [-1, 1]).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='slicing'></a>\n",
    "### 3.4 Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(4, 5), dtype=float32, numpy=\n",
       "array([[ 0.14776349, -1.0173497 , -1.0449705 ,  0.2018814 , -0.3598549 ],\n",
       "       [-1.7339838 ,  0.90426886,  0.56855273, -1.2169818 ,  1.3774033 ],\n",
       "       [-0.4654596 , -0.51368004, -0.5356597 , -0.4981093 , -1.2551429 ],\n",
       "       [ 0.2776104 , -0.52194345,  0.1151574 ,  1.3032064 ,  1.328346  ]],\n",
       "      dtype=float32)>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shuffled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<div>\n",
    "<span style=\"color:#151D3B; font-weight:bold\">Question: 🤔</span><p>\n",
    "Get the value in 2<sup>nd</sup> row and 3<sup>rd</sup> column of <code>shuffled</code>.\n",
    "</div>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Answer\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get a column as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.0449705 ,  0.56855273, -0.5356597 ,  0.1151574 ], dtype=float32)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shuffled[:, 2].numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same for a row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.4654596 , -0.51368004, -0.5356597 , -0.4981093 , -1.2551429 ],\n",
       "      dtype=float32)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shuffled[2, :].numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you guess, it works exactly the same way as NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.0449705 ,  0.2018814 , -0.3598549 ],\n",
       "       [ 0.56855273, -1.2169818 ,  1.3774033 ]], dtype=float32)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get a portion of tensor\n",
    "\n",
    "shuffled[:2, 2:].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.3598549,  1.3774033, -1.2551429,  1.328346 ], dtype=float32)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the last column \n",
    "\n",
    "shuffled[:, -1].numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='Operations'></a>\n",
    "## 4. Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we created tensors, we need to be able to work with these tensors using mathematical operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='Arithmetic'></a>\n",
    "### 4.1 Basic Arithmetic Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of tensors\n",
      "a: (3, 2)\n",
      "b: (3, 2)\n",
      "c: (2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Let's fake up some tensors\n",
    "\n",
    "random_seed = tf.random.Generator.from_seed(2)\n",
    "tf.random.set_seed(3)\n",
    "\n",
    "a = tf.random.normal((3, 2))\n",
    "b = 3 + 2 * tf.random.normal((3, 2))\n",
    "c = 1 - 3 * tf.random.normal((2, 3))\n",
    "\n",
    "print('Shape of tensors')\n",
    "print(f'a: {a.shape}')\n",
    "print(f'b: {b.shape}')\n",
    "print(f'c: {c.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Addition**\n",
    "\n",
    "We can perform the addition at least two ways."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[ 5.502992  ,  2.5837674 ],\n",
       "       [ 6.855619  ,  5.845226  ],\n",
       "       [-0.21574509,  3.5247617 ]], dtype=float32)>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[ 5.502992  ,  2.5837674 ],\n",
       "       [ 6.855619  ,  5.845226  ],\n",
       "       [-0.21574509,  3.5247617 ]], dtype=float32)>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.add(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Subtraction**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[-7.1622663, -6.237022 ],\n",
       "       [-6.605232 , -3.4912095],\n",
       "       [-2.12359  , -3.5434108]], dtype=float32)>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a - b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[-7.1622663, -6.237022 ],\n",
       "       [-6.605232 , -3.4912095],\n",
       "       [-2.12359  , -3.5434108]], dtype=float32)>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.subtract(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Multiplication**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[-5.253785  , -8.056147  ],\n",
       "       [ 0.8426061 ,  5.49453   ],\n",
       "       [-1.1157722 , -0.03295358]], dtype=float32)>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * b "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[-5.253785  , -8.056147  ],\n",
       "       [ 0.8426061 ,  5.49453   ],\n",
       "       [-1.1157722 , -0.03295358]], dtype=float32)>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.multiply(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Division**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[-0.13100992, -0.4141641 ],\n",
       "       [ 0.01860114,  0.25213224],\n",
       "       [-1.2261662 , -0.00263845]], dtype=float32)>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a / b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[-0.13100992, -0.4141641 ],\n",
       "       [ 0.01860114,  0.25213224],\n",
       "       [-1.2261662 , -0.00263845]], dtype=float32)>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.divide(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Module reminder**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[5.502992 , 2.5837674],\n",
       "       [0.1251936, 1.1770082],\n",
       "       [0.7381774, 3.5247617]], dtype=float32)>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a % b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[5.502992 , 2.5837674],\n",
       "       [0.1251936, 1.1770082],\n",
       "       [0.7381774, 3.5247617]], dtype=float32)>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.math.floormod(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Matrix Multiplication**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 3), dtype=float32, numpy=\n",
       "array([[10.669503  ,  0.16929226, -6.425128  ],\n",
       "       [-9.005304  , -0.09658577,  5.115662  ],\n",
       "       [-6.009898  ,  0.03644732,  2.7443535 ]], dtype=float32)>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a @ c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 3), dtype=float32, numpy=\n",
       "array([[10.669503  ,  0.16929226, -6.425128  ],\n",
       "       [-9.005304  , -0.09658577,  5.115662  ],\n",
       "       [-6.009898  ,  0.03644732,  2.7443535 ]], dtype=float32)>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.matmul(a, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Floor Division**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[-1., -1.],\n",
       "       [ 0.,  0.],\n",
       "       [-2., -1.]], dtype=float32)>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a // b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exponent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[-5.7103759e-01, -6.0946631e+00],\n",
       "       [ 1.9622138e-03,  1.6305661e+00],\n",
       "       [-1.6002483e+00, -8.1073011e-07]], dtype=float32)>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a ** 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=float32, numpy=\n",
       "array([[-5.7103759e-01, -6.0946631e+00],\n",
       "       [ 1.9622138e-03,  1.6305661e+00],\n",
       "       [-1.6002483e+00, -8.1073011e-07]], dtype=float32)>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.pow(a, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='Comparison'></a>\n",
    "### 4.2 Comparison Operators "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparison operators are used to compare tensors.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.8296372, -1.8266271],\n",
       "       [ 0.1251936,  1.1770082],\n",
       "       [-1.1696676, -0.0093245]], dtype=float32)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
       "array([[False, False],\n",
       "       [False,  True],\n",
       "       [False, False]])>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Greater than\n",
    "\n",
    "a > 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
       "array([[False,  True],\n",
       "       [False,  True],\n",
       "       [ True, False]])>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Greater than or equal to\n",
    "tf.abs(a) >= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
       "array([[ True,  True],\n",
       "       [ True, False],\n",
       "       [ True,  True]])>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Less than\n",
    "\n",
    "a < 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
       "array([[ True,  True],\n",
       "       [ True,  True],\n",
       "       [ True,  True]])>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Not equal to\n",
    "\n",
    "a != 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
       "array([[False, False],\n",
       "       [False, False],\n",
       "       [False, False]])>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Equal to\n",
    "\n",
    "a == 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='Logical'></a>\n",
    "### 4.3 Logical And Bitwise Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical operators (`AND`, `OR`, `NOT`) are used to compare expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
       "array([[False,  True],\n",
       "       [False,  True],\n",
       "       [ True, False]])>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.abs(a) > 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
       "array([[False, False],\n",
       "       [False, False],\n",
       "       [ True, False]])>"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b <= 3.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`AND` returns `True` if both conditions are `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To compare the expressions that involve tensors, we can use bitwise operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
       "array([[False, False],\n",
       "       [False, False],\n",
       "       [ True, False]])>"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# AND\n",
    "\n",
    "(tf.abs(a) > 1) & (b <= 3.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
       "array([[ True,  True],\n",
       "       [ True,  True],\n",
       "       [False,  True]])>"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NOT\n",
    "\n",
    "~ ((tf.abs(a) > 1)  & (b <= 3.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 2), dtype=bool, numpy=\n",
       "array([[False,  True],\n",
       "       [False,  True],\n",
       "       [ True, False]])>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# OR\n",
    "\n",
    "(tf.abs(a) > 1) | (b <= 3.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [TOP ☝️](#top)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  },
  "vscode": {
   "interpreter": {
    "hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}