Tensor_Basic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How Tensor Work and How to Initialize it.\n",
    "\n",
    "Thanks for the [Amazing tutorials](https://www.youtube.com/playlist?list=PLhhyoLH6IjfxeoooqP9rhU3HJIAVAJ3Vz) by [Aladdin Persson](https://www.youtube.com/@AladdinPersson)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PyTorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tensor = torch.tensor([[1, 2, 3],\n",
    "                          [4, 5, 6]], \n",
    "                          dtype=torch.float32,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    The type of a tensor object is torch.float32\n",
      "    To check the device you can use \"my_tensor.device\": cpu\n",
      "    it will appear like this \n",
      "    tensor([[1., 2., 3.],\n",
      "        [4., 5., 6.]]) \n",
      "    when you print it.\n",
      "    This is the shape of the tensor torch.Size([2, 3])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(f'''\n",
    "    The type of a tensor object is {my_tensor.dtype}\n",
    "    To check the device you can use \"my_tensor.device\": {my_tensor.device}\n",
    "    it will appear like this \n",
    "    {my_tensor} \n",
    "    when you print it.\n",
    "    This is the shape of the tensor {my_tensor.shape}\n",
    "''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0., 0., 0.],\n",
      "        [0., 0., 0.],\n",
      "        [0., 0., 0.]])\n"
     ]
    }
   ],
   "source": [
    "# other way to initizalize tensor is by using\n",
    "empty = torch.empty(size=(3,3)) # empty tensor\n",
    "zero = torch.zeros(size=(3,3)) # zeros tensor\n",
    "random = torch.rand(size=(3,3)) # random tensor by default takes between (0, 1)\n",
    "ones = torch.ones(size=(3,3)) # tensor with one\n",
    "identity = torch.eye(3) # identity tensor\n",
    "range = torch.arange(start=0, end=5, step=1) # for creating a range\n",
    "linspace = torch.linspace(start=0.1, end=1, steps=10) # for creating a value in between\n",
    "normalDist = torch.empty(size=(3,3)).normal_(mean=0, std=1) # for creating random number with Normal distribution\n",
    "unifDist = torch.empty(size=(3,3)).uniform_(0, 10) # for creating random number with unifomr distribution\n",
    "diagonal = torch.diag(torch.ones(3)) # for creating diagonal tensor\n",
    "\n",
    "# feel free to print anything you want for better understanding\n",
    "print(empty)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0, 1, 2, 3])\n"
     ]
    }
   ],
   "source": [
    "# you can also change tensor to other type\n",
    "tensor = torch.arange(4)\n",
    "tensorBool = tensor.bool() # create bool value\n",
    "tensorShort = tensor.short() # create int16\n",
    "tensorLong = tensor.long() # create int64 (important)\n",
    "tensorHalf = tensor.half() # creating float16\n",
    "tensorFloat = tensor.float() # creating float32 (important)\n",
    "tensordouble = tensor.double() # creating float64\n",
    "\n",
    "# feel free to print anything you want for better understanding\n",
    "print(tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# array to Tensor and vice-versa\n",
    "import numpy as np\n",
    "\n",
    "npArray = np.zeros((5,5))\n",
    "tensor = torch.from_numpy(npArray)\n",
    "backToNumpy = tensor.numpy() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Maths\n",
    "x = torch.tensor([1, 2, 3])\n",
    "y = torch.tensor([9, 8, 7])\n",
    "\n",
    "# additions\n",
    "z = x + y\n",
    "z1 = torch.add(x,y)\n",
    "z2 = torch.add(x, y, out=torch.empty(3))\n",
    "\n",
    "# substractions\n",
    "z = x - y\n",
    "\n",
    "# division\n",
    "z = x / y\n",
    "z1 = torch.div(x, y)\n",
    "\n",
    "# inplace operations - can be used for optimizing memory and improving performance by applying the the changes directly\n",
    "t = torch.zeros(3)\n",
    "t.add_(x)\n",
    "t += x # note : t = t + x is not inplace operations\n",
    "t = t + x\n",
    "\n",
    "# Exponentiation\n",
    "z = x ** y\n",
    "\n",
    "# simple comparison\n",
    "z = x > 2\n",
    "\n",
    "# matrix multiplication\n",
    "x1 = torch.rand((2, 5))\n",
    "x2 = torch.rand((5, 3))\n",
    "x3 = x1.mm(x2)\n",
    "\n",
    "# matrix exponentiation\n",
    "matrix_exp = torch.rand(5,5)\n",
    "matrix_exp.matrix_power(3)\n",
    "\n",
    "# element wise multiplication\n",
    "z = x * y \n",
    "\n",
    "# dot product\n",
    "z = x.dot(y)\n",
    "\n",
    "# batch matrix multiplication\n",
    "batch, n, m, p = 32, 10, 20, 30\n",
    "tensor1 = torch.rand((batch, n, m))\n",
    "tensor2 = torch.rand((batch, m, p))\n",
    "out_bmm = torch.bmm(tensor1, tensor2) # the dimension will come out as (batch, n, p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([1 3 5 7 9], shape=(5,), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "# initializing tensors in tensorflow\n",
    "\n",
    "x = tf.constant(4, shape=(1,1), dtype=tf.float32)\n",
    "x = tf.constant([[1, 2, 3],\n",
    "                 [4, 5, 6]])\n",
    "x = tf.ones((3,3))\n",
    "x = tf.zeros((2, 3))\n",
    "x = tf.eye(3)\n",
    "x = tf.random.normal((3, 3), mean=0, stddev=1)\n",
    "x = tf.random.uniform((1,3), minval=0, maxval=1)\n",
    "x = tf.range(start=1, limit=10, delta=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# converting type need to use cast\n",
    "x = tf.cast(x, dtype=tf.float64) \n",
    "# can also use tf.float(16, 32, 64), tf.int(8, 16, 32, 64), tf.bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "# maths\n",
    "x = tf.constant([1, 2, 3])\n",
    "y = tf.constant([9, 8, 7])\n",
    "\n",
    "# additions\n",
    "z = x + y\n",
    "\n",
    "# substractions\n",
    "z = x - y\n",
    "\n",
    "# dividision\n",
    "z = x / y\n",
    "\n",
    "# element wise multiplications\n",
    "z = x * y\n",
    "\n",
    "# dot product\n",
    "z = tf.tensordot(x, y, axes=1)\n",
    "\n",
    "# exponentiation\n",
    "z = x ** 5\n",
    "\n",
    "# matrix multiplication\n",
    "m = tf.constant([[1, 2, 3]])\n",
    "n = tf.constant([[2, 3, 4],\n",
    "                [1, 2, 5],\n",
    "                [6, 6, 6]])\n",
    "z = tf.matmul(m, n)\n",
    "# or you can use this\n",
    "z = m @ n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "deep-learning",
   "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.11.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}