Lab1_Linear_algebra_in_Python_with_Numpy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyN6Dg+dVtl4ZrpfQrbB6Yxo",
      "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/hussain0048/Natural-language-processing/blob/main/Lab1_Linear_algebra_in_Python_with_Numpy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "cDLHWu99bYOD"
      },
      "outputs": [],
      "source": [
        "import numpy as np  # The swiss knife of the data scientist.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Defining lists and numpy arrays**\n"
      ],
      "metadata": {
        "id": "lsOTgNKibsm5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "alist = [1, 2, 3, 4, 5]   # Define a python list. It looks like an np array\n",
        "narray = np.array([1, 2, 3, 4]) # Define a numpy array"
      ],
      "metadata": {
        "id": "vzkJED15cC2g"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(alist)\n",
        "print(narray)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fQIZlvsIcO5R",
        "outputId": "d1b55c92-2882-4c5a-b027-ecb3544c2878"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 5]\n",
            "[1 2 3 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Algebraic operators on NumPy arrays vs. Python lists**"
      ],
      "metadata": {
        "id": "xMy_Up9TcqP-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(narray + narray)\n",
        "print(alist + alist)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8yBz9fwFcucX",
        "outputId": "40d77594-6556-4a8b-95e0-365f7a56f0a4"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2 4 6 8]\n",
            "[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(narray * 3)\n",
        "print(alist * 3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8YwOGR-RdmKx",
        "outputId": "59560bff-1629-4063-ecf6-23845c639651"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ 3  6  9 12]\n",
            "[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Matrix or Array of Arrays**\n"
      ],
      "metadata": {
        "id": "Pyi3V20NebD_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "npmatrix1 = np.array([narray, narray, narray]) # Matrix initialized with NumPy arrays\n",
        "npmatrix2 = np.array([alist, alist, alist]) # Matrix initialized with lists\n",
        "npmatrix3 = np.array([narray, [1, 1, 1, 1], narray]) # Matrix initialized with both types"
      ],
      "metadata": {
        "id": "UYcyJ_LTetVJ"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(npmatrix1)\n",
        "print(npmatrix2)\n",
        "print(npmatrix3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YHcRY7Lyezfy",
        "outputId": "7b464498-e066-43f6-95af-86bf1bf9948e"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 3 4]\n",
            " [1 2 3 4]\n",
            " [1 2 3 4]]\n",
            "[[1 2 3 4 5]\n",
            " [1 2 3 4 5]\n",
            " [1 2 3 4 5]]\n",
            "[[1 2 3 4]\n",
            " [1 1 1 1]\n",
            " [1 2 3 4]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 1:\n",
        "\n",
        "okmatrix = np.array([[1, 2], [3, 4]]) # Define a 2x2 matrix\n",
        "print(okmatrix) # Print okmatrix\n",
        "print(okmatrix * 2) # Print a scaled version of okmatrix"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-NwMJe1wfDO0",
        "outputId": "be283633-507c-40fb-98e6-9cec10597702"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2]\n",
            " [3 4]]\n",
            "[[2 4]\n",
            " [6 8]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Scaling and translating matrices**\n"
      ],
      "metadata": {
        "id": "lXuTpSjmfw6X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Scale by 2 and translate 1 unit the matrix\n",
        "result = okmatrix * 2 + 1 # For each element in the matrix, multiply by 2 and add 1\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PI2TxyTPjwzY",
        "outputId": "7aa34f34-3ab5-420f-dfd6-6c575bf1c848"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[3 5]\n",
            " [7 9]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Add two sum compatible matrices\n",
        "result1 = okmatrix + okmatrix\n",
        "print(result1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "198AF5Mkj341",
        "outputId": "e64fb327-75cd-45b9-a86e-a4f7ddb2473e"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[2 4]\n",
            " [6 8]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Subtract two sum compatible matrices. This is called the difference vector\n",
        "result2 = okmatrix - okmatrix\n",
        "print(result2)"
      ],
      "metadata": {
        "id": "9ME4XlOrj83o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "result = okmatrix * okmatrix # Multiply each element by itself\n",
        "print(result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wBu5hAlckCk_",
        "outputId": "32681bd7-fc48-4cd2-a0fe-7d07c41686a4"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  4]\n",
            " [ 9 16]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Transpose a matrix**\n"
      ],
      "metadata": {
        "id": "ENNq84SClpjs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "matrix3x2 = np.array([[1, 2], [3, 4], [5, 6]]) # Define a 3x2 matrix\n",
        "print('Original matrix 3 x 2')\n",
        "print(matrix3x2)\n",
        "print('Transposed matrix 2 x 3')\n",
        "print(matrix3x2.T)"
      ],
      "metadata": {
        "id": "lrTiFS8KlweF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nparray = np.array([1, 2, 3, 4]) # Define an array\n",
        "print('Original array')\n",
        "print(nparray)\n",
        "print('Transposed array')\n",
        "print(nparray.T)"
      ],
      "metadata": {
        "id": "zJXXCxOrl5BW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nparray = np.array([[1, 2, 3, 4]]) # Define a 1 x 4 matrix. Note the 2 level of square brackets\n",
        "print('Original array')\n",
        "print(nparray)\n",
        "print('Transposed array')\n",
        "print(nparray.T)"
      ],
      "metadata": {
        "id": "CnYPmvcfmENx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Get the norm of a nparray or matrix**\n"
      ],
      "metadata": {
        "id": "ay176tIgmiWw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nparray1 = np.array([1, 2, 3, 4]) # Define an array\n",
        "norm1 = np.linalg.norm(nparray1)"
      ],
      "metadata": {
        "id": "aX_IkTlbpjCI"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nparray2 = np.array([[1, 2], [3, 4]]) # Define a 2 x 2 matrix. Note the 2 level of square brackets\n",
        "norm2 = np.linalg.norm(nparray2) \n"
      ],
      "metadata": {
        "id": "N1eG4n7Jpz_m"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(norm1)\n",
        "print(norm2)"
      ],
      "metadata": {
        "id": "fOu5IOLep7BG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nparray2 = np.array([[1, 1], [2, 2], [3, 3]]) # Define a 3 x 2 matrix. "
      ],
      "metadata": {
        "id": "5de4AFLaqTpN"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "normByCols = np.linalg.norm(nparray2, axis=0) # Get the norm for each column. Returns 2 elements\n",
        "normByRows = np.linalg.norm(nparray2, axis=1) # get the norm for each row. Returns 3 elements"
      ],
      "metadata": {
        "id": "mc8pBsoWqZXd"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(normByCols)\n",
        "print(normByRows)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Uoqbohj6qfWr",
        "outputId": "18cab625-a4c6-4855-b5ea-ab913c4fbdf2"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3.74165739 3.74165739]\n",
            "[1.41421356 2.82842712 4.24264069]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **The dot product between arrays: All the flavors**\n"
      ],
      "metadata": {
        "id": "LuPO5R1aqnDH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nparray1 = np.array([0, 1, 2, 3]) # Define an array\n",
        "nparray2 = np.array([4, 5, 6, 7]) # Define an array"
      ],
      "metadata": {
        "id": "sgMMszUzvR-0"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "flavor1 = np.dot(nparray1, nparray2) # Recommended way\n",
        "print(flavor1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5tN26NSWvWiO",
        "outputId": "74649e0f-1fba-426a-cf4d-ef18f5902586"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "38\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "flavor2 = np.sum(nparray1 * nparray2) # Ok way\n",
        "print(flavor2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7UpEorpEvcu4",
        "outputId": "07e9f38c-e349-4a74-cd40-a6f76032634c"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "38\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "flavor3 = nparray1 @ nparray2         # Geeks way\n",
        "print(flavor3)"
      ],
      "metadata": {
        "id": "PPKZf1P-vjvY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# As you never should do:             # Noobs way\n",
        "flavor4 = 0\n",
        "for a, b in zip(nparray1, nparray2):\n",
        "    flavor4 += a * b\n",
        "    \n",
        "print(flavor4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L3exP18ovqxl",
        "outputId": "56c82fe6-841d-4ec5-a01e-36f0a8c04cc5"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "38\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "norm1 = np.dot(np.array([1, 2]), np.array([3, 4])) # Dot product on nparrays\n",
        "norm2 = np.dot([1, 2], [3, 4]) # Dot product on python lists"
      ],
      "metadata": {
        "id": "9bVgF0pDvxYs"
      },
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(norm1, '=', norm2 )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rbjl63sev1k8",
        "outputId": "10f3e78a-a69d-4b99-e878-9783063f8d4e"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "11 = 11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Sums by rows or columns**\n"
      ],
      "metadata": {
        "id": "FDve78hnxO7n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nparray2 = np.array([[1, -1], [2, -2], [3, -3]]) # Define a 3 x 2 matrix. \n",
        "\n",
        "sumByCols = np.sum(nparray2, axis=0) # Get the sum for each column. Returns 2 elements\n",
        "sumByRows = np.sum(nparray2, axis=1) # get the sum for each row. Returns 3 elements"
      ],
      "metadata": {
        "id": "kSsbcuOLxa28"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print('Sum by columns: ')\n",
        "print(sumByCols)\n",
        "print('Sum by rows:')\n",
        "print(sumByRows)"
      ],
      "metadata": {
        "id": "k9wimICIxkDl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Get the mean by rows or columns**\n"
      ],
      "metadata": {
        "id": "Ex3FxfmTxpup"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nparray2 = np.array([[1, -1], [2, -2], [3, -3]]) # Define a 3 x 2 matrix. Chosen to be a matrix with 0 mean\n",
        "\n",
        "mean = np.mean(nparray2) # Get the mean for the whole matrix\n",
        "meanByCols = np.mean(nparray2, axis=0) # Get the mean for each column. Returns 2 elements\n",
        "meanByRows = np.mean(nparray2, axis=1) # get the mean for each row. Returns 3 elements"
      ],
      "metadata": {
        "id": "avqZfAsl13fH"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print('Matrix mean: ')\n",
        "print(mean)\n",
        "print('Mean by columns: ')\n",
        "print(meanByCols)\n",
        "print('Mean by rows:')\n",
        "print(meanByRows)"
      ],
      "metadata": {
        "id": "1frz3NoF17wy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Center the columns of a matrix**\n"
      ],
      "metadata": {
        "id": "eO7ev87o1_zt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nparray2 = np.array([[1, 1], [2, 2], [3, 3]]) # Define a 3 x 2 matrix. \n",
        "\n",
        "nparrayCentered = nparray2 - np.mean(nparray2, axis=0) # Remove the mean for each column\n",
        "\n",
        "print('Original matrix')\n",
        "print(nparray2)\n",
        "print('Centered by columns matrix')\n",
        "print(nparrayCentered)\n",
        "\n",
        "print('New mean by column')\n",
        "print(nparrayCentered.mean(axis=0))"
      ],
      "metadata": {
        "id": "FhNx-It-2HpP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nparray2 = np.array([[1, 3], [2, 4], [3, 5]]) # Define a 3 x 2 matrix. \n",
        "\n",
        "nparrayCentered = nparray2.T - np.mean(nparray2, axis=1) # Remove the mean for each row\n",
        "nparrayCentered = nparrayCentered.T # Transpose back the result\n",
        "\n",
        "print('Original matrix')\n",
        "print(nparray2)\n",
        "print('Centered by columns matrix')\n",
        "print(nparrayCentered)\n",
        "\n",
        "print('New mean by rows')\n",
        "print(nparrayCentered.mean(axis=1))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UuBTStwj2XIl",
        "outputId": "8bd9a887-1da6-4e27-b5dd-a201131fee71"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original matrix\n",
            "[[1 3]\n",
            " [2 4]\n",
            " [3 5]]\n",
            "Centered by columns matrix\n",
            "[[-1.  1.]\n",
            " [-1.  1.]\n",
            " [-1.  1.]]\n",
            "New mean by rows\n",
            "[0. 0. 0.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nparray2 = np.array([[1, 3], [2, 4], [3, 5]]) # Define a 3 x 2 matrix. \n",
        "\n",
        "mean1 = np.mean(nparray2) # Static way\n",
        "mean2 = nparray2.mean()   # Dinamic way\n",
        "\n",
        "print(mean1, ' == ', mean2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZYgh2mso2bkD",
        "outputId": "cef9e3ec-ec58-467a-a54c-1ac5e6660048"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.0  ==  3.0\n"
          ]
        }
      ]
    }
  ]
}