numpy_primer.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "numpy_primer.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPMBdb44YjTJ7uod4+TyD0Y",
      "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/TurkuNLP/Text_Mining_Course/blob/master/numpy_primer.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ueip4VWsm2_9"
      },
      "source": [
        "# Small numpy primer\n",
        "\n",
        "* This notebook tries to collect some basic tips for numpy, staying within the area needed for this course"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "czpMeK1QnEI-"
      },
      "source": [
        "# ndarray\n",
        "\n",
        "* `ndarray` is n-dimensional array\n",
        "* you will meet it in very many different places throughout this course\n",
        "* when working with `torch` and `tensorflow` when we switch over to deep learning, the corresponding concept there will be that of \"tensor\"\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wn3stydcl-Ip"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-UykBYsBnslR",
        "outputId": "2015690b-5fe2-46af-f88f-d13a65d45ace"
      },
      "source": [
        "# this is a small 2D array as a normal python list, a 3x3 matrix if you will\n",
        "M=[[0,1,2],[3,4,5],[6,7,8]]\n",
        "D=np.asarray(M) #now we turn it into numpy's array\n",
        "print(\"Type of D:\", type(D))\n",
        "print(\"D itself:\\n\",D)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Type of D: <class 'numpy.ndarray'>\n",
            "D itself:\n",
            " [[0 1 2]\n",
            " [3 4 5]\n",
            " [6 7 8]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cDrF7uGcLd8U"
      },
      "source": [
        "#Here is a 3-dimensional array\n",
        "D3=np.asarray([[[1],[2]],[[3],[4]]])\n"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "95SQltEOoYPr"
      },
      "source": [
        "## shape\n",
        "\n",
        "* Shape is an important property, it tells you how many dimensions / axes the array has, and how large they are\n",
        "* Our array D is 3x3, meaning it has two axes and each is 3 elements long\n",
        "* Array D3 is 2x2x1, meaning it has three axes, the axes 0 and 1 are 2 elements long and the axis 2 is 1 element long\n",
        "* You can think of these as n-dimensional tables\n",
        "* A 2D matrix is simply a special case of an ndarray where the number of axes is 2\n",
        "* A vector is simply a special case of an ndarray where the number of axes is 1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mczyIR5Lord8",
        "outputId": "7ba2eaa3-c457-45ed-94ee-bca72fa28884"
      },
      "source": [
        "#You can ask for shape through an attribute .shape, you get back a tuple\n",
        "print(\"D.shape\",D.shape)\n",
        "print(\"D3.shape\",D3.shape)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "D.shape (3, 3)\n",
            "D3.shape (2, 2, 1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dS8w3phhNHPm"
      },
      "source": [
        "## Beware of singleton axes\n",
        "\n",
        "* Often you get caught in the difference between shapes (1,N) and (N,) because both look like a vector\n",
        "* You might also think of it so that `[[1]]` is not the same as `[1]` which is not the same as `1`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7GWdrYE-Mp41",
        "outputId": "57dd7f1c-db05-4cac-da00-edcabe078ade"
      },
      "source": [
        "print(\"A (1,4) ndarray:\", np.array([[1,2,3,4]]))\n",
        "print(\"A (4,) ndarray:\", np.array([1,2,3,4]))"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A (1,4) ndarray: [[1 2 3 4]]\n",
            "A (4,) ndarray: [1 2 3 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O7xAwrM1Np8s"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AalrVbsPo1j6"
      },
      "source": [
        "## Elementary slicing\n",
        "\n",
        "* Slicing in numpy arrays is a science in its own right, but its basic functionality is not super-complex\n",
        "* You can slice a number of axes at once, going from left to right"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ne7CPTPaf5Ya",
        "outputId": "40d6836c-cbd5-46d4-d36a-f31ba686d52a"
      },
      "source": [
        "D"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1, 2],\n",
              "       [3, 4, 5],\n",
              "       [6, 7, 8]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3AdQ_YpAftwX",
        "outputId": "497ea428-4ee8-47b4-de58-a7b879033bed"
      },
      "source": [
        "D[0]"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 1, 2])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hwdxRyLQf0-x",
        "outputId": "f92e3335-c446-495c-bcb4-5937187c297d"
      },
      "source": [
        "D[0,0]"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n_1FJbGggMzW",
        "outputId": "d7bec7f4-1ae2-4840-dc49-9b2fd02a1bfe"
      },
      "source": [
        "#You can do ranges as usual, in all axes\n",
        "D[0:2,0:2] #first two elements on the first axis, first two elements on the second axis"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1],\n",
              "       [3, 4]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "13ZvAcxGlPXV",
        "outputId": "806e1792-68bd-4124-ebfc-2c97bee1824c"
      },
      "source": [
        "D[0:2,:] #First two elements on the first axis, everything on the second axis"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1, 2],\n",
              "       [3, 4, 5]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vd9ANETTgrKF",
        "outputId": "dc361062-9614-4186-fe8d-c2d941d348fa"
      },
      "source": [
        "#Note the difference between the slice and index in the following:\n",
        "\n",
        "D[0:1,:2] #Because 0:1 is a slice, even though it is 1-long, it will produce 1-long axis"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "21xtHMiUg53i",
        "outputId": "f3b17415-29dc-4157-8e16-f39225fd9227"
      },
      "source": [
        "D[0,:2]  #Because 0 is an index, it will select the row and not result in a 1-long axis"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 1])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IANILyLuhXGf"
      },
      "source": [
        "## Singleton axes\n",
        "\n",
        "* Sometimes you need to add a singleton axis to match the expected dimensionality\n",
        "* Sometimes you need to drop it for the same reason\n",
        "* squeeze/expand_dims\n",
        "* You can add/remove these singleton axes easily, because they are only a matter of interpretation of the data\n",
        "* Add: `1` into `[1]` into `[[1]]` into `[[[1]]]`...\n",
        "* Remove: ...the opposite"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tt6wjNUohmJ3",
        "outputId": "15e0050a-322d-45a1-8daa-0b175b494ff5"
      },
      "source": [
        "D[:1,:] #shorthand writing for [0:1,0:3], you don't need to say the start if it is 0 and you don't need to say end if it is, well, end"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QmFeCdiChva6",
        "outputId": "de2684c3-a85b-40d0-b7cd-e8b5e74a792e"
      },
      "source": [
        "D_sliced=D[:1,:]\n",
        "D_sliced.shape #here you see the singleton first axis"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OB2eCKiPiMYz",
        "outputId": "20377c1a-669e-4726-a1fa-4b005b8dd47c"
      },
      "source": [
        "print(D_sliced.squeeze()) #drops all singleton axes\n",
        "print(D_sliced.squeeze().shape)"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 1 2]\n",
            "(3,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NaIbfPMBibnk",
        "outputId": "85b1803c-12f7-45f2-c71f-d0e63879606e"
      },
      "source": [
        "D_sliced_more_dims=np.expand_dims(D_sliced,0) #adds a singleton axis at dimension index 0, i.e. as the first axis\n",
        "D_sliced_more_dims.shape\n"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 1, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cXLTO_RZjjZ7",
        "outputId": "e6f361a3-ac35-4fb1-d3c1-8a43569a1a03"
      },
      "source": [
        "D_sliced_more_dims.squeeze() #get rid of the extra singleton axes"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 1, 2])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DvFI6LmIkBuR"
      },
      "source": [
        "## More on axes\n",
        "* These often matter in different numpy functions\n",
        "* Many functions work along one or several axes and have different default expectations\n",
        "* The way things go is often quite mind-bending"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-lXgY-lOmX3h",
        "outputId": "a71fbf6b-d593-4bf5-b6d0-394a20359924"
      },
      "source": [
        "D"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1, 2],\n",
              "       [3, 4, 5],\n",
              "       [6, 7, 8]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sntUbn6bmaYq",
        "outputId": "2b946aab-4c12-40b8-cd55-dc4ae403f693"
      },
      "source": [
        "np.max(D) #no axis specified: maximum is calculated across all of the data"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J11ZmwLqmdK1",
        "outputId": "080144dd-98a0-4744-b917-a022568db7f2"
      },
      "source": [
        "np.max(D,axis=0) #maximum is calculated along the first axis"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([6, 7, 8])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fUMQNlCYmisd",
        "outputId": "03a8bd31-407b-4484-c1e9-f98837f95d0d"
      },
      "source": [
        "np.max(D,axis=1) #maximum is calculated along the second axis"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2, 5, 8])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wAGrUV8unaTY"
      },
      "source": [
        "## Sorting"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "biw9K0twnd0l",
        "outputId": "855d8458-d86a-4a8d-f7a0-cbce77a8280e"
      },
      "source": [
        "R=np.random.random((3,4)) #Gives a radnom array of 3x4\n",
        "R"
      ],
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.54407135, 0.85856531, 0.75063223, 0.88297569],\n",
              "       [0.00304345, 0.71736475, 0.61511061, 0.62537479],\n",
              "       [0.78482089, 0.4472638 , 0.85887243, 0.46054136]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SaC8Jjl8ngOi",
        "outputId": "5f3e975e-f422-457a-828a-80ef8b144f9a"
      },
      "source": [
        "np.sort(R,axis=0) #sort along the first axis (sort rows within columns)"
      ],
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.00304345, 0.4472638 , 0.61511061, 0.46054136],\n",
              "       [0.54407135, 0.71736475, 0.75063223, 0.62537479],\n",
              "       [0.78482089, 0.85856531, 0.85887243, 0.88297569]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zjQAWbJZnjFc",
        "outputId": "0bd4e1c0-a8a8-48d8-960f-26b45cbd1ac5"
      },
      "source": [
        "np.sort(R,axis=1) #sort along the second axis (sort columns within rows)"
      ],
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.54407135, 0.75063223, 0.85856531, 0.88297569],\n",
              "       [0.00304345, 0.61511061, 0.62537479, 0.71736475],\n",
              "       [0.4472638 , 0.46054136, 0.78482089, 0.85887243]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qvHw_LmOoStz"
      },
      "source": [
        "#Arg-sorting\n",
        "* exactly like sorting, but gives the indices, not the values\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bpmvEMGVoa6C",
        "outputId": "3ade7a43-3621-4910-8efa-b4d42cdd5b25"
      },
      "source": [
        "np.argsort(R,axis=0)"
      ],
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 1, 2],\n",
              "       [0, 1, 0, 1],\n",
              "       [2, 0, 2, 0]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9K_zf-Fxon6Q",
        "outputId": "a3511ef7-e403-46b8-9795-069529fe7294"
      },
      "source": [
        "np.argsort(R,axis=1)"
      ],
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 2, 1, 3],\n",
              "       [0, 2, 3, 1],\n",
              "       [1, 3, 0, 2]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tCb0mas5pBER"
      },
      "source": [
        "# Looping over arrays\n",
        "* so many ways to do it..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hGeHk7BepGKM",
        "outputId": "e4da4570-b384-4156-a55b-597cada7cfaf"
      },
      "source": [
        "D"
      ],
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1, 2],\n",
              "       [3, 4, 5],\n",
              "       [6, 7, 8]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qYGrvEdapKGL",
        "outputId": "236cccb0-d24c-4356-cad6-b2d65085f3af"
      },
      "source": [
        "#Perhaps the cleanest way...?\n",
        "for i in range(D.shape[0]):\n",
        "    for j in range(D.shape[1]):\n",
        "        item=D[i,j]\n",
        "        print(item)"
      ],
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}