TensorFlow_Introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-5u3a4csUPyn"
   },
   "source": [
    "# TensorFlow 2.0 Introduction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "F7ThfbiQl96l"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/james/anaconda3/envs/learn_tensor/bin/jupyter\n"
     ]
    }
   ],
   "source": [
    "!which jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JJjNMaSClWhg"
   },
   "source": [
    "## Importing TensorFlow\n",
    "The first step here is going to be to select the correct version of TensorFlow from within collabratory!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "vGcE8x2Gkw9K"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "UsageError: Line magic function `%tensorflow_version` not found.\n"
     ]
    }
   ],
   "source": [
    "%tensorflow_version 2.x  # this line is not required unless you are in a notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "id": "4N7XbNDVY8P3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<module 'tensorflow._api.v2.version' from '/home/james/anaconda3/envs/learn_tensor/lib/python3.8/site-packages/tensorflow/_api/v2/version/__init__.py'>\n"
     ]
    }
   ],
   "source": [
    "# Imports\n",
    "import tensorflow as tf  # now import the tensorflow module\n",
    "import numpy as np\n",
    "print(tf.version)  # make sure the version is 2.x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TAk6QhGUwQRt"
   },
   "source": [
    "### Creating Tensors\n",
    "Below is an example of how to create some different tensors.\n",
    "\n",
    "You simply define the value of the tensor and the datatype and you are good to go! It's worth mentioning that usually we deal with tensors of numeric data, it is quite rare to see string tensors.\n",
    "\n",
    "For a full list of datatypes please refer to the following guide.\n",
    "\n",
    "https://www.tensorflow.org/api_docs/python/tf/dtypes/DType?version=stable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "epGskXdjZHzu"
   },
   "outputs": [],
   "source": [
    "# using tf.Variable to create different tensors. \n",
    "string = tf.Variable(\"this is a string\", tf.string) \n",
    "number = tf.Variable(324, tf.int16)\n",
    "floating = tf.Variable(3.567, tf.float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<tf.Variable 'Variable:0' shape=() dtype=float32, numpy=3.567>\n"
     ]
    }
   ],
   "source": [
    "print(floating)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D0_H71HMaE-5"
   },
   "source": [
    "###Rank/Degree of Tensors\n",
    "Another word for rank is degree, these terms simply mean the number of dimensions involved in the tensor. What we created above is a *tensor of rank 0*, also known as a scalar. \n",
    "\n",
    "Now we'll "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "hX_Cc5IfjQ6-"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(), dtype=int32, numpy=1>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# creating tensors of higher degrees/ranks. \n",
    "rank1_tensor = tf.Variable([\"Test\"], tf.string) \n",
    "tf.rank(rank1_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "id": "Zrj0rAWLnMNv",
    "outputId": "b8b34a8c-fc6e-40c6-9fd6-294d1253631e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(), dtype=int32, numpy=2>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank2_tensor = tf.Variable([[\"test\", \"ok\"], [\"test\", \"yes\"]], tf.string)\n",
    "tf.rank(rank2_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "L_NRXsFOraYa"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([2, 2])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the shape** of a tensor using the shape attribute.\n",
    "rank2_tensor.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wVDmLJeFs086"
   },
   "source": [
    "\n",
    "The number of elements of a tensor is the product of the sizes of all its shapes. There are often many shapes that have the same number of elements, making it convient to be able to change the shape of a tensor.\n",
    "\n",
    "The example below shows how to change the shape of a tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "dZ8Rbs2xtNqj"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[[1. 1. 1.]\n",
      "  [1. 1. 1.]]], shape=(1, 2, 3), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "# Changing Shape of tensor\n",
    "# tf.ones generates just 1s as elements in the object\n",
    "tensor1 = tf.ones([1,2,3])  # tf.ones() creates a shape [1,2,3] tensor full of ones\n",
    "print(tensor1)                                                                       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "IFNmUxaEv6s3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[[1.]\n",
      "  [1.]\n",
      "  [1.]]\n",
      "\n",
      " [[1.]\n",
      "  [1.]\n",
      "  [1.]]], shape=(2, 3, 1), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "tensor2 = tf.reshape(tensor1, [2,3,1])  # reshape existing data to shape [2,3,1]\n",
    "print(tensor2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[1. 1.]\n",
      " [1. 1.]\n",
      " [1. 1.]], shape=(3, 2), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "tensor3 = tf.reshape(tensor2, [3, -1])  # -1 tells the tensor to calculate the size of the dimension in that place\n",
    "print(tensor3)\n",
    "# The numer of elements in the reshaped tensor is always the same"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q88pJucBolsp"
   },
   "source": [
    "###Slicing Tensors\n",
    "You may be familiar with the term \"slice\" in python and its use on lists, tuples etc. Well the slice operator can be used on tensors to select specific axes or elements.\n",
    "\n",
    "When we slice or select elements from a tensor, we can use comma seperated values inside the set of square brackets. Each subsequent value refrences a different dimension of the tensor.\n",
    "\n",
    "Ex: ```tensor[dim1, dim2, dim3]```\n",
    "\n",
    "I've included a few examples that will hopefully help illustrate how we can manipulate tensors with the slice operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "b0YrD-hRqD-W"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(2, shape=(), dtype=int32)\n",
      "(4, 5)\n"
     ]
    }
   ],
   "source": [
    "# Creating a 2D tensor\n",
    "matrix = [[1,2,3,4,5],\n",
    "          [6,7,8,9,10],\n",
    "          [11,12,13,14,15],\n",
    "          [16,17,18,19,20]]\n",
    "\n",
    "tensor = tf.Variable(matrix, dtype=tf.int32) \n",
    "print(tf.rank(tensor))\n",
    "print(tensor.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'Variable:0' shape=(4, 5) dtype=int32, numpy=\n",
       "array([[ 1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10],\n",
       "       [11, 12, 13, 14, 15],\n",
       "       [16, 17, 18, 19, 20]], dtype=int32)>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "Wd85uGI7qyfC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(3, shape=(), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "# Now lets select some different rows and columns from our tensor\n",
    "\n",
    "three = tensor[0,2]  # selects the 3rd element from the 1st row\n",
    "print(three)  # -> 3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([1 2 3 4 5], shape=(5,), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "row1 = tensor[0]  # selects the first row\n",
    "print(row1)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([ 1  6 11 16], shape=(4,), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "column1 = tensor[:, 0]  # selects the first column\n",
    "print(column1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[ 6  7  8  9 10]\n",
      " [16 17 18 19 20]], shape=(2, 5), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "row_2_and_4 = tensor[1::2]  # selects second and fourth row\n",
    "print(row_2_and_4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([ 6 11], shape=(2,), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "column_1_in_row_2_and_3 = tensor[1:3, 0]\n",
    "print(column_1_in_row_2_and_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UU4MMhB_rxvz"
   },
   "source": [
    "###Types of Tensors\n",
    "Before we go to far, I will mention that there are diffent types of tensors. These are the most used and we will talk more in depth about each as they are used.\n",
    "- Variable\n",
    "- Constant\n",
    "- Placeholder\n",
    "- SparseTensor\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(), dtype=int32, numpy=1>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Constant 1-D Tensor from a python list.\n",
    "const_tensor = tf.constant([1, 2, 3, 4, 5, 6])\n",
    "tf.rank(const_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(), dtype=int32, numpy=2>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Constant 2-D rom a numpy array\n",
    "arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "const_tensor_2 = tf.constant(arr)\n",
    "tf.rank(const_tensor_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F2OoXbe7aSVl"
   },
   "source": [
    "#Sources\n",
    "Most of the information is taken direclty from the TensorFlow website which can be found below.\n",
    "\n",
    "https://www.tensorflow.org/guide/tensor"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "name": "TensorFlow-Introduction.ipynb",
   "provenance": []
  },
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}