python_advance/numpy_intro.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyO5XuwIHi28FlwaSFN+VnN8",
      "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/jngadiub/ML_course_Pavia_23/blob/main/python_advance/numpy_intro.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Introduction to Numpy\n",
        "\n",
        "Based on [W3Schools tutorial](https://www.w3schools.com/python/numpy/default.asp) and [Wuhan DL Lab](https://github.com/farakiko/wuhan_DL_labs/blob/master/general/Intro_Numpy.ipynb).\n",
        "\n",
        "[**NumPy**](https://github.com/numpy/numpy) is short for \"*Numerical Python*\". It is a Python library used for working with arrays and it is used in almost all numerical computation using Python. It has functions for working in domain of linear algebra, fourier transform, and matrices. It was created in 2005 by Travis Oliphant. It is an open source project and you can use it freely.\n",
        "\n",
        "**Why Use NumPy?**\n",
        "\n",
        "In Python we have lists that serve the purpose of arrays, but they are slow to process. NumPy aims to provide an array object that is up to 50x faster than traditional Python lists. Arrays are very frequently used in data science, where speed and resources are very important.\n",
        "\n",
        "NumPy provides high-performance vector, matrix and higher-dimensional data structures for Python. It is implemented in C and Fortran so when calculations are vectorized (formulated with vectors and matrices), performance are very good.\n",
        "\n",
        "The array object in NumPy is called `ndarray`, it provides a lot of supporting functions that make working with arrays very easy.\n",
        "\n",
        "**Why is NumPy Faster Than Lists?**\n",
        "\n",
        "NumPy arrays are stored at one continuous place in memory unlike lists, so processes can access and manipulate them very efficiently. This behavior is called *locality of reference* in computer science. This is the main reason why NumPy is faster than lists. Also it is optimized to work with latest CPU architectures.\n",
        "\n",
        "**Which Language is NumPy written in?**\n",
        "\n",
        "NumPy is a Python library and is written partially in Python, but most of the parts that require fast computation are written in C or C++.\n",
        "\n",
        "**Useful Links**\n",
        "\n",
        "* http://jrjohansson.github.io/numericalpython.html\n",
        "* http://numpy.org\n",
        "* https://scipy.github.io/old-wiki/pages/Tentative_NumPy_Tutorial\n"
      ],
      "metadata": {
        "id": "z9YNWQz91pir"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating Arrays\n",
        "\n",
        "We can create a NumPy `ndarray` object by using the `array()` function:"
      ],
      "metadata": {
        "id": "nC0hcE_i4jam"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "v40zpWNv1mZQ"
      },
      "outputs": [],
      "source": [
        "#To use NumPy we need to import the numpy module first:\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Create and inspect the array\n",
        "arr = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "print(arr)\n",
        "print(type(arr))"
      ],
      "metadata": {
        "id": "Bx_GCO-yfLDB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "There are a number of ways to initialize new NumPy arrays, for example from:\n",
        "\n",
        "* a Python list or tuples\n",
        "* using functions that are dedicated to generating numpy arrays, such as arange, linspace, etc.\n",
        "* reading data from files\n",
        "\n"
      ],
      "metadata": {
        "id": "zBZUpv694284"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A dimension in arrays is one level of array depth in nested arrays, i.e. arrays that have arrays as their elements:\n",
        "\n",
        "**0-D array**"
      ],
      "metadata": {
        "id": "BNaWNuyufdaJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array(42)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "sdfDuwke6BDm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**1-D array**"
      ],
      "metadata": {
        "id": "rwdU_5M-6IHp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([1, 2, 3, 4, 5])\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "2R5f1fvx6JpX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**2-D array**"
      ],
      "metadata": {
        "id": "4wFvM0S56M6O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "j4cAzkzr6Oe_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**3-D array**"
      ],
      "metadata": {
        "id": "TV4Sr4hR6QJ9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "pi3u0BFw6SQ3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "NumPy arrays provides the `ndim` attribute that returns an integer that tells us how many dimensions the array have:"
      ],
      "metadata": {
        "id": "U1oPVbk85li7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = np.array(42)\n",
        "b = np.array([1, 2, 3, 4, 5])\n",
        "c = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])\n",
        "\n",
        "print(a.ndim)\n",
        "print(b.ndim)\n",
        "print(c.ndim)\n",
        "print(d.ndim)"
      ],
      "metadata": {
        "id": "PPGYNFcR6XaP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "So far the `numpy.ndarray` looks awefully much like a Python list (or nested list). Why not simply use Python lists for computations instead of creating a new array type?\n",
        "\n",
        "There are several reasons:\n",
        "\n",
        "* Python lists are very general. They can contain any kind of object. They are dynamically typed. They do not support mathematical functions such as matrix and dot multiplications, etc. Implementating such functions for Python lists would not be very efficient because of the dynamic typing.\n",
        "* Numpy arrays are statically typed and homogeneous. The type of the elements is determined when array is created.\n",
        "* Numpy arrays are memory efficient.\n",
        "* Because of the static typing, fast implementation of mathematical functions such as multiplication and addition of numpy arrays can be implemented in a compiled language (C and Fortran is used).\n"
      ],
      "metadata": {
        "id": "L-Q3pTfkfr5j"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Fast Array Generation\n",
        "\n",
        "For larger arrays it is inpractical to initialize the data manually, using explicit python lists. Instead we can use one of the many functions in numpy that generates arrays of different forms. Some of the more common are:\n",
        "\n",
        "**arange**\n"
      ],
      "metadata": {
        "id": "sfU7FzxqgOmO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.arange(0, 10, 1) # arguments: start, stop, step\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "vqj664yagXEC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.arange(-1, 1, 0.1)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "M6e8R1RHg3_S"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**linspace and logspace**"
      ],
      "metadata": {
        "id": "EhAsL5x_hEL0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.linspace(0, 10, 25)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "oDcsCSp3hFyB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.logspace(0, 10, 10, base=np.e)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "twK8ayCihXt0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**mgrid**"
      ],
      "metadata": {
        "id": "i3ptx8y5hmYU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x, y = np.mgrid[0:5, 0:5]"
      ],
      "metadata": {
        "id": "RMELNlbWhn1p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(x)"
      ],
      "metadata": {
        "id": "SbaDUlR3hq38"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(y)"
      ],
      "metadata": {
        "id": "fCaw04JzhrdA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**random data**"
      ],
      "metadata": {
        "id": "8YCQszkch5zB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# uniform random numbers in [0,1]\n",
        "arr = np.random.rand(5,5)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "sYcK8wNCh68n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# standard normal distributed random numbers\n",
        "arr = np.random.randn(5,5)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "18k094seiQmJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**diag**"
      ],
      "metadata": {
        "id": "tgj0f-N2iWhS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# a diagonal matrix\n",
        "arr = np.diag([1,2,3])\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "3xJnMm5XiXlb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**zeros and ones**"
      ],
      "metadata": {
        "id": "kL1oVhtDicb7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.zeros((3,3))\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "_CZqAIYqie4T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.ones((3,3))\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "mRxYTFtGii0d"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Access Array Elements\n",
        "\n",
        "Array indexing is the same as accessing elements in python arrays:"
      ],
      "metadata": {
        "id": "gB54NXq-7IID"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([1, 2, 3, 4])\n",
        "\n",
        "print(arr[0]) \n",
        "print(arr[1])\n",
        "print(arr[2] + arr[3])  "
      ],
      "metadata": {
        "id": "3Td7vDFE7as1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To access elements from 2-D arrays we can use comma separated integers representing the dimension and the index of the element.\n",
        "\n",
        "Think of 2-D arrays like a table with rows and columns, where the dimension represents the row and the index represents the column:"
      ],
      "metadata": {
        "id": "u0wX-jT_7AFj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])\n",
        "print(arr)\n",
        "\n",
        "print('2nd element on 1st row: ', arr[0, 1]) \n",
        "print('5th element on 2nd row: ', arr[1, 4])"
      ],
      "metadata": {
        "id": "YD_8xR6t73xv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To access elements from 3-D arrays we can use comma separated integers representing the dimensions and the index of the element:"
      ],
      "metadata": {
        "id": "wFFq13U18A3S"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])\n",
        "print(arr[0, 1, 2]) "
      ],
      "metadata": {
        "id": "UC7ktd-R8HBB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In the example above, the first number represents the first dimension, which contains two arrays:\n",
        "\n",
        "`[[1, 2, 3], [4, 5, 6]]` and `[[7, 8, 9], [10, 11, 12]]`\n",
        "\n",
        "Since we selected `0`, we are left with the first array: `[[1, 2, 3], [4, 5, 6]]`.\n",
        "\n",
        "The second number represents the second dimension, which also contains two arrays:\n",
        "\n",
        "`[1, 2, 3]` and `[4, 5, 6]`\n",
        "\n",
        "Since we selected `1`, we are left with the second array: `[4, 5, 6]`.\n",
        "\n",
        "The third number represents the third dimension, which contains three values: `4`, `5`, and `6`. Since we selected `2`, we end up with the third value: `6`."
      ],
      "metadata": {
        "id": "UMmlyCjS8Kl5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Array Sclicing\n",
        "\n",
        "Slicing for NumPy arrays is similar to python arrays (see notebook [`python_intro_part1.ipynb`](https://github.com/jngadiub/ML_course_Pavia_23/blob/main/python_basics/python_intro_part1.ipynb)). Let's see here a few more features. "
      ],
      "metadata": {
        "id": "oNcRSWaABHW9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `step` value can be used to determine the step of the slicing. The example below returns every other element from index `1` to index `5`:"
      ],
      "metadata": {
        "id": "4lAEXnTnC6HW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
        "print(arr[1:5:2]) "
      ],
      "metadata": {
        "id": "a2W2bPmgCcUR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Exercise 1: print every other element of the entire array.*\n",
        "\n",
        "*Exercise 2: create a 2D array and from the second element of the first dimension, slice elements from index 1 to index 4.*\n",
        "\n",
        "*Exercise 3: create a 2D array and from both elements of the first dimension, return the element with index 2.*\n",
        "\n",
        "*Exercise 4: create a 2D array and from the both elements of the first dimension, slice elements from index 1 to index 4.*"
      ],
      "metadata": {
        "id": "aeu4oobRCvs8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Data Types\n",
        "\n",
        "Using the `dtype` (data type) property of an `ndarray`, we can see what type the data of an array has:\n"
      ],
      "metadata": {
        "id": "0JTm2JP3FEll"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([1, 2, 3, 4])\n",
        "print(arr.dtype) "
      ],
      "metadata": {
        "id": "5zCaDYW_D0p8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We get an error if we try to assign a value of the wrong type to an element in a numpy array:\n"
      ],
      "metadata": {
        "id": "xsFWZPl1KbPK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr[0] = \"hello\"   # error on purpose\n"
      ],
      "metadata": {
        "id": "Nb2najF0KdIl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we want, we can explicitly define the type of the array data when we create it, using the `dtype` keyword argument:\n",
        "\n",
        "**Example 1**\n"
      ],
      "metadata": {
        "id": "6Y36CmgDKoSz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([1, 2, 3, 4], dtype=complex)\n",
        "print(arr)\n",
        "print(arr.dtype) "
      ],
      "metadata": {
        "id": "2-0mFD3eFMUl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Example 2**"
      ],
      "metadata": {
        "id": "6ZO38RfKLNtc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([0, 2, 3, 4], dtype=bool)\n",
        "print(arr)\n",
        "print(arr.dtype)"
      ],
      "metadata": {
        "id": "O0eHLd8oLPB7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Common type that can be used with dtype are: `int`, `float`, `complex`, `bool`, `object`, etc.\n",
        "\n",
        "We can also explicitly define the bit size of the data types, for example: `int64`, `int16`, `float32`, `complex128`.\n"
      ],
      "metadata": {
        "id": "Puo8ONS7K7Mr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([0, 2, 3, 4], dtype='float32')\n",
        "print(arr)\n",
        "print(arr.dtype)"
      ],
      "metadata": {
        "id": "pc28K74rLgyd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A way to change the data type of an existing array, is to make a copy of the array with the `astype()` method. This function creates a copy of the array, and allows you to specify the data type as a parameter:\n",
        "\n"
      ],
      "metadata": {
        "id": "4fnbOmEqC3wk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([1.1, 2.1, 3.1])\n",
        "\n",
        "newarr = arr.astype('int32')\n",
        "\n",
        "print(newarr)\n",
        "print(newarr.dtype)"
      ],
      "metadata": {
        "id": "214KpnW6L8Yf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Array Copy\n",
        "\n",
        "To achieve high performance, assignments in Python usually do not copy the underlaying objects. This is important for example when objects are passed between functions, to avoid an excessive amount of memory copying when it is not necessary (techincal term: *pass by reference*).\n"
      ],
      "metadata": {
        "id": "BvNM6h2RPtCc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = np.array([[1, 2], [3, 4]])\n",
        "print(A)"
      ],
      "metadata": {
        "id": "5u8aI5OjP33s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# now B is referring to the same array data as A \n",
        "B = A "
      ],
      "metadata": {
        "id": "1A5QO4xmQVtL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# changing B affects A\n",
        "B[0,0] = 10\n",
        "print(B)"
      ],
      "metadata": {
        "id": "arSMb9SCQc_B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(A)"
      ],
      "metadata": {
        "id": "VhQszrd5QjIn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we want to avoid this behavior, so that when we get a new completely independent object `B` copied from `A`, then we need to do a so-called \"*deep copy*\" using the function `copy`:"
      ],
      "metadata": {
        "id": "WjDgbc-5QrEb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "B = np.copy(A)\n",
        "# now, if we modify B, A is not affected\n",
        "B[0,0] = -5\n",
        "print(B)"
      ],
      "metadata": {
        "id": "B3Crh8QSQyl7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(A)"
      ],
      "metadata": {
        "id": "5Dbmn2zjRG4m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Array Shape\n",
        "\n",
        "The shape of an array is the number of elements in each dimension. NumPy arrays have an attribute called `shape` that returns a tuple with each index having the number of corresponding elements:"
      ],
      "metadata": {
        "id": "R0DupXJxMScb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
        "print(arr.shape)"
      ],
      "metadata": {
        "id": "_1TMUUTnMdVX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The example above returns `(2, 4)`, which means that the array has 2 dimensions, where the first dimension has 2 elements and the second has 4.\n",
        "\n",
        "*Exercise: create an array with 5 dimensions using `ndmin` and a vector with four elements and verify that last dimension has value 4.*"
      ],
      "metadata": {
        "id": "W9TDyQUbMqQ7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Reshaping means changing the shape of an array. By reshaping we can add or remove dimensions or change number of elements in each dimension.\n",
        "\n",
        "**Reshape From 1-D to 2-D**"
      ],
      "metadata": {
        "id": "xkJaE_jFMqOH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])\n",
        "print(\"Before reshaping:\",arr.shape)\n",
        "\n",
        "arr = arr.reshape(4, 3)\n",
        "print(\"After reshaping\",arr.shape)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "OHr9LrziNQaT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Reshape From 1-D to 3-D**"
      ],
      "metadata": {
        "id": "H35R2HZxNhpZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])\n",
        "print(\"Before reshaping:\",arr.shape)\n",
        "\n",
        "arr = arr.reshape(2, 3, 2)\n",
        "print(\"After reshaping\",arr.shape)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "4lsts4YRNisL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Can We Reshape Into any Shape?**\n",
        "Yes, as long as the elements required for reshaping are equal in both shapes.\n",
        "\n",
        "We can reshape an 8 elements 1D array into a matrix of 2 rows and 4 columns but we cannot reshape it into a matrix of 3 rows and 3 columns as that would require 3x3 = 9 elements, while we have only 8 in the original 1D array."
      ],
      "metadata": {
        "id": "-ccho4psOCya"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
        "arr = arr.reshape(3, 3) #error on purpose"
      ],
      "metadata": {
        "id": "MhBJDdL3OWI-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You are allowed to have one \"unknown\" dimension. Meaning that you do not have to specify an exact number for one of the dimensions in the reshape method. Pass `-1` as the value, and NumPy will calculate this number for you:"
      ],
      "metadata": {
        "id": "mTD06jZqOnSL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
        "print(\"Before reshaping:\",arr.shape)\n",
        "\n",
        "arr = arr.reshape(2, 2, -1)\n",
        "print(\"After reshaping\",arr.shape)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "E1MUQrwIOqgr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Flattening array means converting a multidimensional array into a 1D array. We can use the `flatten` method to do this:"
      ],
      "metadata": {
        "id": "Qi0ShDxlO3t7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([[1, 2], [3, 4]])\n",
        "print(\"Before flattening:\",arr.shape)\n",
        "\n",
        "arr = arr.flatten()\n",
        "print(\"After flattening:\",arr.shape)"
      ],
      "metadata": {
        "id": "xlymOSJKPXlu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Note**: both the `reshape` and `flatten` functions create a deep copy of the data.\n"
      ],
      "metadata": {
        "id": "KPJx7IpzRT1R"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Iterating Arrays\n",
        "\n",
        "Iterating means going through elements one by one. As we deal with multi-dimensional arrays in numpy, we can do this using basic `for` loop of python.\n",
        "\n",
        "If we iterate on a 1-D array it will go through each element one by one:\n",
        "\n"
      ],
      "metadata": {
        "id": "pANzkXVIUAOH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([1, 2, 3])\n",
        "for x in arr: print(x) "
      ],
      "metadata": {
        "id": "Pfqqol4rUJtZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In a 2-D array it will go through all the rows:"
      ],
      "metadata": {
        "id": "kLIPJSrCUNog"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "for x in arr: print(x) "
      ],
      "metadata": {
        "id": "D_PaRpbmUQYC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In a 3-D array it will go through all the 2-D arrays:"
      ],
      "metadata": {
        "id": "uXuqW86EUmAc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])\n",
        "for x in arr: print(x) "
      ],
      "metadata": {
        "id": "JRjlPPY0UnEF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To return the actual elements, the scalars, we have to iterate the arrays in each dimension:"
      ],
      "metadata": {
        "id": "JiDW9c-mUT60"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])\n",
        "for x in arr:\n",
        "  for y in x:\n",
        "    for z in y: print(z) "
      ],
      "metadata": {
        "id": "CA0ipCIpUfJI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In basic for loops, iterating through each scalar of an array we need to use n for loops which can be difficult to write for arrays with very high dimensionality. The function `nditer()` is a helping function that can be used from very basic to very advanced iterations. It solves some basic issues which we face in iteration, lets go through it with examples. "
      ],
      "metadata": {
        "id": "MbRvOws5UzsP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])\n",
        "for x in np.nditer(arr): print(x) "
      ],
      "metadata": {
        "id": "WI7D7GqMU8z0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also iterate using a fix step size:"
      ],
      "metadata": {
        "id": "X5l-ce6_VE7y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Iterate through every scalar element of the 2D array skipping 1 element:\n",
        "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
        "for x in np.nditer(arr[:, ::2]): print(x) "
      ],
      "metadata": {
        "id": "1MQslUdCVHQw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Sometimes we require corresponding index of the element while iterating, the `ndenumerate()` method can be used for those usecases:"
      ],
      "metadata": {
        "id": "cD6mLC6JVnzO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#1D array\n",
        "arr = np.array([1, 2, 3])\n",
        "for idx, x in np.ndenumerate(arr): print(idx, x)"
      ],
      "metadata": {
        "id": "7qJhCFCjVqRA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#2D array\n",
        "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
        "for idx, x in np.ndenumerate(arr): print(idx, x)"
      ],
      "metadata": {
        "id": "b2UsIVygVweH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Joining Arrays\n",
        "\n",
        "Joining means putting contents of two or more arrays in a single array. In NumPy we join arrays by axes. We pass a sequence of arrays that we want to join to the `concatenate()` function, along with the axis. If axis is not explicitly passed, it is taken as `0`."
      ],
      "metadata": {
        "id": "DO4LiiYGV2lj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Example 1\n",
        "arr1 = np.array([1, 2, 3])\n",
        "print(\"arr1 shape:\",arr1.shape)\n",
        "arr2 = np.array([4, 5, 6])\n",
        "print(\"arr2 shape:\",arr2.shape)\n",
        "\n",
        "arr = np.concatenate((arr1, arr2))\n",
        "print(\"arr shape:\",arr.shape)\n",
        "print(arr) "
      ],
      "metadata": {
        "id": "SpWZLpqbWBXL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Example 2\n",
        "arr1 = np.array([[1, 2], [3, 4]])\n",
        "print(\"arr1 shape:\",arr1.shape)\n",
        "print(arr1)\n",
        "arr2 = np.array([[5, 6], [7, 8]])\n",
        "print(\"arr2 shape:\",arr2.shape)\n",
        "print(arr2)\n",
        "\n",
        "arr = np.concatenate((arr1, arr2), axis=1)\n",
        "print(\"arr shape:\",arr.shape)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "a00U_X57WMp6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Example 3\n",
        "arr1 = np.array([[1, 2], [3, 4]])\n",
        "print(\"arr1 shape:\",arr1.shape)\n",
        "print(arr1)\n",
        "arr2 = np.array([[5, 6], [7, 8]])\n",
        "print(\"arr2 shape:\",arr2.shape)\n",
        "print(arr2)\n",
        "\n",
        "arr = np.concatenate((arr1, arr2), axis=0)\n",
        "print(\"arr shape:\",arr.shape)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "GRd6jbg4WSzo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Exercise: concatenate two 3D arrays on the the third dimension and return the final shape.*"
      ],
      "metadata": {
        "id": "M-j3scJAXYYE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Stacking is same as concatenation, the only difference is that stacking is done along a new axis. We can concatenate two 1-D arrays along the second axis which would result in putting them one over the other, ie. stacking. We pass a sequence of arrays that we want to join to the `stack()` method along with the axis. If axis is not explicitly passed it is taken as 0."
      ],
      "metadata": {
        "id": "cTN6LceoXLCe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr1 = np.array([1, 2, 3])\n",
        "print(\"arr1 shape:\",arr1.shape)\n",
        "arr2 = np.array([4, 5, 6])\n",
        "print(\"arr2 shape:\",arr2.shape)\n",
        "\n",
        "arr = np.stack((arr1, arr2), axis=1)\n",
        "print(\"arr shape:\",arr.shape)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "Hg9lq8h1UTT8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "NumPy provides the helper functions `hstack()`, `vstack()`, and `dstack()` to stack along rows, columns, and height (or depth), respectively:\n",
        "\n"
      ],
      "metadata": {
        "id": "hiKINLMtYLS3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Stack along rows\n",
        "arr1 = np.array([1, 2, 3])\n",
        "print(\"arr1 shape:\",arr1.shape)\n",
        "arr2 = np.array([4, 5, 6])\n",
        "print(\"arr2 shape:\",arr2.shape)\n",
        "\n",
        "arr = np.hstack((arr1, arr2))\n",
        "print(\"arr shape:\",arr.shape)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "7VMb7OXZO79h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Stack along columns\n",
        "arr1 = np.array([1, 2, 3])\n",
        "print(\"arr1 shape:\",arr1.shape)\n",
        "arr2 = np.array([4, 5, 6])\n",
        "print(\"arr2 shape:\",arr2.shape)\n",
        "\n",
        "arr = np.vstack((arr1, arr2))\n",
        "print(\"arr shape:\",arr.shape)\n",
        "print(arr) "
      ],
      "metadata": {
        "id": "gDLtqjEfYio1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Stack along depth\n",
        "arr1 = np.array([1, 2, 3])\n",
        "print(\"arr1 shape:\",arr1.shape)\n",
        "arr2 = np.array([4, 5, 6])\n",
        "print(\"arr2 shape:\",arr2.shape)\n",
        "\n",
        "arr = np.dstack((arr1, arr2))\n",
        "print(\"arr shape:\",arr.shape)\n",
        "print(arr) "
      ],
      "metadata": {
        "id": "rQjavcH96nEZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "With `newaxis`, we can insert new dimensions in an array, for example converting a vector to a column or row matrix:\n"
      ],
      "metadata": {
        "id": "c-wDNWoqz8Ip"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "v = np.array([1,2,3])\n",
        "print(v)\n",
        "print(v.shape)"
      ],
      "metadata": {
        "id": "ZAoqhTXe0A9I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# make a column matrix of the vector v\n",
        "a = v[:, np.newaxis]\n",
        "print(a)\n",
        "print(a.shape)"
      ],
      "metadata": {
        "id": "mm37Bxpy0GDC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# make a row matrix of the vector v\n",
        "a = v[np.newaxis,:]\n",
        "print(a)\n",
        "print(a.shape)"
      ],
      "metadata": {
        "id": "sw6s9WXt0s1o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Other methods to join and reshape arrays are `repeat` and `tile`:"
      ],
      "metadata": {
        "id": "d-KG8WX51Vst"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# repeat each element 3 times\n",
        "np.repeat([1,2,5], 3)"
      ],
      "metadata": {
        "id": "HkKiR7Ar1ymN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = np.array([[1, 2], [3, 4]])"
      ],
      "metadata": {
        "id": "sLj5Qhdy13i-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# repeat each element from a 3 times\n",
        "np.repeat(a, 3)"
      ],
      "metadata": {
        "id": "RzIj48mM14Iv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# tile the matrix a 3 times \n",
        "np.tile(a, 3)"
      ],
      "metadata": {
        "id": "ksNaO3Oy2BG6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Array Search\n",
        "\n",
        "You can search an array for a certain value, and return the indexes that get a match using the `where()` method:"
      ],
      "metadata": {
        "id": "BAbKbSHYasoW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([1, 2, 3, 4, 5, 4, 4])\n",
        "x = np.where(arr == 4)\n",
        "print(x) "
      ],
      "metadata": {
        "id": "uUCDTzEua02d"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The example above will return a tuple: `(array([3, 5, 6],)`. This means that the value 4 is present at index `3`, `5`, and `6`.\n",
        "\n",
        "*Exercise 1: create a NumPy array of integers and find the indexes where the values are even.*\n",
        "\n",
        "*Exercise 2: create a NumPy array of integers and find the indexes where the values are odd.*"
      ],
      "metadata": {
        "id": "L5F6HcF-a69l"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Filtering Arrays\n",
        "\n",
        "Getting some elements out of an existing array and creating a new array out of them is called *filtering*. In NumPy, you filter an array using a boolean index list.\n",
        "\n",
        "If the value at an index is `True` that element is contained in the filtered array, if the value at that index is `False` that element is excluded from the filtered array."
      ],
      "metadata": {
        "id": "AdpshTOwbzOL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([41, 42, 43, 44])\n",
        "print(\"Before filtering:\")\n",
        "print(arr)\n",
        "\n",
        "x = [True, False, True, False]\n",
        "\n",
        "arr = arr[x]\n",
        "print(\"After filtering:\")\n",
        "print(arr) "
      ],
      "metadata": {
        "id": "1hg01UEyb-_9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In the example above we hard-coded the `True` and `False` values, but the common use is to create a filter array based on conditions.\n",
        "\n",
        "For example, we can create a filter array that will return only values higher than `42`:"
      ],
      "metadata": {
        "id": "quwnVtBGc9MS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([41, 42, 43, 44])\n",
        "print(\"Before filtering:\")\n",
        "print(arr)\n",
        "\n",
        "# Create an empty list\n",
        "filter_arr = []\n",
        "\n",
        "# go through each element in arr\n",
        "for element in arr:\n",
        "  # if the element is higher than 42, set the value to True, otherwise False:\n",
        "  if element > 42:\n",
        "    filter_arr.append(True)\n",
        "  else:\n",
        "    filter_arr.append(False)\n",
        "\n",
        "arr = arr[filter_arr]\n",
        "\n",
        "print(\"Filter:\")\n",
        "print(filter_arr)\n",
        "print(\"After filtering:\")\n",
        "print(arr) "
      ],
      "metadata": {
        "id": "P76Y9ozydDK3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The above examples are quite a common task in NumPy and NumPy provides a nice way to tackle it. We can directly substitute the array instead of the iterable variable in our condition and it will work just as we expect it to:"
      ],
      "metadata": {
        "id": "Z2Jlagy_dXnp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([41, 42, 43, 44])\n",
        "print(\"Before filtering:\")\n",
        "print(arr)\n",
        "\n",
        "filter_arr = arr > 42\n",
        "print(\"Filter:\")\n",
        "print(filter_arr)\n",
        "\n",
        "arr = arr[filter_arr]\n",
        "print(\"After filtering:\")\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "iDo5KrfDddk7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Exercise: create a filter array that will return only even elements from the original array.*"
      ],
      "metadata": {
        "id": "PH4Dj4ttdxYL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Linear Algebra\n",
        "\n",
        "Vectorizing code is the key to writing efficient numerical calculation with Python/Numpy. That means that as much as possible of a program should be formulated in terms of matrix and vector operations, like matrix-matrix multiplication.\n"
      ],
      "metadata": {
        "id": "G46Nv9WKmVsZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Scalar-array operations**\n",
        "\n",
        "We can use the usual arithmetic operators to multiply, add, subtract, and divide arrays with scalar numbers.\n"
      ],
      "metadata": {
        "id": "Ztqo5FgeoUHQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "v1 = np.arange(0, 5)\n",
        "print(v1)"
      ],
      "metadata": {
        "id": "NQwqYKuhoYmf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "arr = v1 * 2\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "RedPDYuDoaYV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "arr = v1 + 2\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "qKkB-4UAomEL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "A = np.array([[n+m*10 for n in range(5)] for m in range(5)])\n",
        "print(A)\n",
        "print(A*2)\n",
        "print(A+2)"
      ],
      "metadata": {
        "id": "OeYM77rpo2GW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Element-wise array-array operations**\n",
        "\n",
        "When we add, subtract, multiply and divide arrays with each other, the default behaviour is element-wise operations:\n"
      ],
      "metadata": {
        "id": "cP9CtCGApL6j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(A * A) # element-wise multiplication"
      ],
      "metadata": {
        "id": "A5rrkvF-pUGA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Broadcasting**\n",
        "\n",
        "(see https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)\n",
        "\n",
        "If we multiply arrays with compatible shapes, we get an element-wise multiplication of each row:\n"
      ],
      "metadata": {
        "id": "qS4b6EJKphxv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A.shape, v1.shape"
      ],
      "metadata": {
        "id": "WOm5vnbjpllm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "A * v1"
      ],
      "metadata": {
        "id": "eyH4SGacpnMz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Matrix algebra**\n",
        "\n",
        "What about matrix mutiplication? There are two ways. We can either use the `dot` function, which applies a matrix-matrix, matrix-vector, or inner vector multiplication to its two arguments:"
      ],
      "metadata": {
        "id": "XiwWMfsDqCbc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = np.random.randint(5, size=(2,2))\n",
        "print(A)\n",
        "print(np.dot(A, A))"
      ],
      "metadata": {
        "id": "rNSN_vk3pN5Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "v1 = np.random.randint(5, size=(2,))\n",
        "print(v1)\n",
        "print(np.dot(A, v1))"
      ],
      "metadata": {
        "id": "rP6OX4lMsLz8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.dot(v1, v1)"
      ],
      "metadata": {
        "id": "4MKifqihpKvr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Alternatively, we can cast the array objects to the type matrix. This changes the behavior of the standard arithmetic operators `+`, `-`, `*` to use matrix algebra.\n"
      ],
      "metadata": {
        "id": "YpXmFKwmuSN2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "M = np.matrix(A)\n",
        "v = np.matrix(v1).T # make it a column vector"
      ],
      "metadata": {
        "id": "ZzCh5n0EuVrF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "v"
      ],
      "metadata": {
        "id": "VsZsoRKxvIMi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "M * M"
      ],
      "metadata": {
        "id": "Kw1xUVsGvLX8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "M * v"
      ],
      "metadata": {
        "id": "NYd0Ow_zvLQw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# inner product\n",
        "v.T * v"
      ],
      "metadata": {
        "id": "rOAijMuRvVLQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# with matrix objects, standard matrix algebra applies\n",
        "v + M*v"
      ],
      "metadata": {
        "id": "mKe3ljA-vZNk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we try to add, subtract or multiply objects with incomplatible shapes we get an error:"
      ],
      "metadata": {
        "id": "CbQ8E_XmvVDP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "v = np.matrix([1,2,3,4,5,6]).T\n",
        "np.shape(M), np.shape(v)"
      ],
      "metadata": {
        "id": "AKQYlcEevhl4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "M * v #error on purpose"
      ],
      "metadata": {
        "id": "mTQiSYKrvnt6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Array/Matrix transformations**\n",
        "\n",
        "Above we have used the `.T` to transpose the matrix object `v`. We could also have used the transpose function to accomplish the same thing.\n",
        "\n",
        "Other mathematical functions that transforms matrix objects are:"
      ],
      "metadata": {
        "id": "ZmWXU845wBDp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "C = np.matrix([[1j, 2j], [3j, 4j]])\n",
        "C"
      ],
      "metadata": {
        "id": "iU-IfsEtwHT-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.conjugate(C)"
      ],
      "metadata": {
        "id": "2tY-lTvnwLkP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Hermitian conjugate: transpose + conjugate\n",
        "C.H"
      ],
      "metadata": {
        "id": "b-DbRNQFwRKU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can extract the real and imaginary parts of complex-valued arrays using `real` and `imag` methods:"
      ],
      "metadata": {
        "id": "-lVELkDVwZYB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.real(C) # same as: C.real"
      ],
      "metadata": {
        "id": "Pe05a1Euwcg0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.imag(C) # same as: C.imag"
      ],
      "metadata": {
        "id": "zqMC1kUxwf0Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Or we can extract the complex argument and absolute value:"
      ],
      "metadata": {
        "id": "rBs9dkU8wkqP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.angle(C+1)"
      ],
      "metadata": {
        "id": "dVq5Qq3dwnXh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.abs(C)"
      ],
      "metadata": {
        "id": "OIPJ_dKMwj-r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Matrix computations**"
      ],
      "metadata": {
        "id": "fvorqUnhwzMU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#inverse\n",
        "np.linalg.inv(C) # equivalent to C.I "
      ],
      "metadata": {
        "id": "NeTuXB3uw1Tq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "C.I * C"
      ],
      "metadata": {
        "id": "ppjzGOp5w7hw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Determinant\n",
        "np.linalg.det(C)"
      ],
      "metadata": {
        "id": "YU87DYVrxF1O"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.linalg.det(C.I)"
      ],
      "metadata": {
        "id": "cxotS2vYxLGz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Arrays I/O\n",
        "\n",
        "**Comma-separated values (CSV)**\n",
        "\n",
        "A very common file format for data files are the comma-separated values (CSV), or related format such as TSV (tab-separated values). To read data from such file into Numpy arrays we can use the `numpy.genfromtxt()` function. For example,\n"
      ],
      "metadata": {
        "id": "S_vdDKDrizL4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Fetch data file from githun\n",
        "!curl https://raw.githubusercontent.com/jngadiub/ML_course_Pavia_23/main/python_advance/stockholm_td_adj.dat -o stockholm_td_adj.dat\n",
        "\n",
        "#Look first 10 lines of file\n",
        "!head stockholm_td_adj.dat"
      ],
      "metadata": {
        "id": "H4y9RhgLi6Gr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data = np.genfromtxt('stockholm_td_adj.dat')\n",
        "data.shape"
      ],
      "metadata": {
        "id": "8aCRAaTcbtsq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# we need this for plotting -- more on matlplotlib in next tutorial\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline"
      ],
      "metadata": {
        "id": "fWEkKt_vkDD4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Now we plot the data\n",
        "fig, ax = plt.subplots(figsize=(14,4))\n",
        "ax.plot(data[:,0]+data[:,1]/12.0+data[:,2]/365, data[:,5])\n",
        "ax.axis('tight')\n",
        "ax.set_title('tempeatures in Stockholm')\n",
        "ax.set_xlabel('year')\n",
        "ax.set_ylabel('temperature (C)');"
      ],
      "metadata": {
        "id": "IcLcy5kQkLSk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Using `numpy.savetxt()` we can store a Numpy array to a file in CSV format:\n"
      ],
      "metadata": {
        "id": "nx8P4zqdkuKi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.random.rand(3,3)\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "v8vblAIvkjgy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.savetxt(\"random-matrix.csv\", arr)\n",
        "!ls ./"
      ],
      "metadata": {
        "id": "d9sB12d-k1fo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Let's look at the file\n",
        "!cat random-matrix.csv"
      ],
      "metadata": {
        "id": "B-_u0KNPk6FH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.savetxt(\"random-matrix.csv\", arr, fmt='%.5f') # fmt specifies the format\n",
        "!cat random-matrix.csv"
      ],
      "metadata": {
        "id": "gh4zUGuclAJJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Numpy's native file format**\n",
        "\n",
        "Useful when storing and reading back NumPy array data. Use the functions `numpy.save()` and `numpy.load()`:\n"
      ],
      "metadata": {
        "id": "CaGgUwK-lY8F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.random.rand(3,3)\n",
        "print(arr)\n",
        "\n",
        "np.save(\"random-matrix.npy\", arr)\n",
        "!ls ./"
      ],
      "metadata": {
        "id": "JKsst7wQli5t"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.load(\"random-matrix.npy\")\n",
        "print(arr)"
      ],
      "metadata": {
        "id": "aPSaWeOnlN4m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Data processing\n",
        "\n",
        "Often it is useful to store datasets in Numpy arrays. Numpy provides a number of functions to calculate statistics of datasets in arrays.\n",
        "\n",
        "For example, let's calculate some properties data from the Stockholm temperature dataset used above.\n"
      ],
      "metadata": {
        "id": "r9fIMmqFxfn1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# reminder, the tempeature dataset is stored in the data variable:\n",
        "np.shape(data)"
      ],
      "metadata": {
        "id": "jfwpB97dl0mQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**mean**"
      ],
      "metadata": {
        "id": "1JtcX9cMxs7c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# the temperature data is in column 3\n",
        "np.mean(data[:,3])"
      ],
      "metadata": {
        "id": "OuQakvJDxqHu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The daily mean temperature in Stockholm over the last 200 year so has been about 6.2 C."
      ],
      "metadata": {
        "id": "CRyst33FxyZy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**standard deviations and variance**"
      ],
      "metadata": {
        "id": "X0pdBFlmx2yU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.std(data[:,3]), np.var(data[:,3])"
      ],
      "metadata": {
        "id": "hrTmzDsxxvnT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**min and max**"
      ],
      "metadata": {
        "id": "WaXzSUAIx6-t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# lowest daily average temperature\n",
        "data[:,3].min()"
      ],
      "metadata": {
        "id": "9In49l4cx9vk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# highest daily average temperature\n",
        "data[:,3].max()"
      ],
      "metadata": {
        "id": "fTZ5sCevyBmQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**sum, prod, and trace**"
      ],
      "metadata": {
        "id": "PQDZLeD7yHqB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "d = np.arange(0, 10)\n",
        "d"
      ],
      "metadata": {
        "id": "Dj71beDcyEnJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# sum up all elements\n",
        "np.sum(d)"
      ],
      "metadata": {
        "id": "V8_eS_lnyMzQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# product of all elements\n",
        "np.prod(d+1)"
      ],
      "metadata": {
        "id": "TndGIrRgyPYy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# cummulative sum\n",
        "np.cumsum(d)"
      ],
      "metadata": {
        "id": "zfDLw-aKySaD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# cummulative product\n",
        "np.cumprod(d+1)"
      ],
      "metadata": {
        "id": "4M8WWKBlyU_V"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# same as: diag(A).sum()\n",
        "np.trace(A)"
      ],
      "metadata": {
        "id": "55_2-MS3yj7G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Calculations with higher-dimensional data**\n",
        "\n",
        "When functions such as `min`, `max`, etc., is applied to multidimensional arrays, it is sometimes useful to apply the calculation to the entire array, and sometimes only on a row or column basis. Using the `axis` argument we can specify how these functions should behave:\n"
      ],
      "metadata": {
        "id": "_25lEXO-zHaj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "m = np.random.rand(3,3)\n",
        "m"
      ],
      "metadata": {
        "id": "6_ccRgFVymm3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# global max\n",
        "m.max()"
      ],
      "metadata": {
        "id": "Qys3LK0lzT3m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# max in each column\n",
        "m.max(axis=0)"
      ],
      "metadata": {
        "id": "jk2oa7ZQzW5I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# max in each row\n",
        "m.max(axis=1)"
      ],
      "metadata": {
        "id": "q3nK8FJizaP6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Note:** Many other functions and methods in the array and matrix classes accept the same (optional) `axis` keyword argument.\n"
      ],
      "metadata": {
        "id": "VLr1JcBCzmOf"
      }
    }
  ]
}