SIT744_Prac1_Intro.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.6"
    },
    "colab": {
      "name": "SIT744_Prac1_Intro.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "OFd1iQ14JlJV",
        "CKiCG9NCJlJj"
      ],
      "toc_visible": true
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9grGwZt-JlHg",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "SIT 744 - Deep Learning\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RRNczKjiJlHj",
        "colab_type": "text"
      },
      "source": [
        "# Practical 1: Software installation and setup\n",
        "\n",
        "\n",
        "*Dr Wei Luo*\n",
        "\n",
        "<span style=\"color:maroon\">\n",
        "This first tutorial is for everyone to set up the programming environment, get familiar with the essential coding and programming knowledge required for this unit.</span>\n",
        "\n",
        "- The official programming language for this unit is **python**. Besides, most of our programming tasks, as well as assessments in the assignments, will be using **Jupyter** notebook.\n",
        "    \n",
        "- For deep learning, we will use **Google TensorFlow** (version 2)\n",
        "\n",
        "- <span style=\"color:maroon\">*Students should be warned that this unit is **NOT** about teaching Python or a programming language*!\n",
        "\n",
        "\n",
        "For those who have less experience with Python, please go through the Review section on **Scipy** at the end of this notebook. Learning a programming language takes time and you should practice regularly. Successful completion of this unit is, however, not resting on the in-depth knowledge of Python, it only requires sufficient command of Python to perform machine learning tasks involved. Hence with the basic knowledge of Python and well-planned practice through this unit, you should be able to complete the unit well.\n",
        "\n",
        "In summary, **the purpose of this session is to illustrate**\n",
        "\n",
        "1. How to install all necessary software and tools for the course, including: Python, Jupyter Notebooks.\n",
        "2. How to install and test installed Numpy and Scikit-Learn packages.\n",
        "\n",
        "*You are expected to follow these steps on your own during the prac time*. The tutor will be available to assist if you need assistance. You can also post questions on the unit forum if you have questions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tphDlXz5JlHl",
        "colab_type": "text"
      },
      "source": [
        "## Task 1: Installing Python \n",
        "\n",
        "There are many ways to install Python and packages but the most straightforward way is using a scientific distribution such as [Anaconda Scientific Distribution](https://store.continuum.io/cshop/anaconda/). We highly recommend you to use **anaconda** because it comes with most of the modules you need for the course, e.g IPython, numpy, matplotlib and you don't need to install them individually. Follow these steps to install anaconda:\n",
        "\n",
        "1. Download Anaconda with Python 3.x compatible with your OS from https://www.anaconda.com/download/.\n",
        "2. Choose the corresponding OS (Windows, MacOS, Linux) and CPU_architecture (32- or 64-bit), click to download intstallation file.\n",
        "3. Open the downloaded file and click on Next\n",
        "4. Click on I Agree\n",
        "5. Click on Next\n",
        "6. Click on Next and complete the installation.\n",
        "7. Check out the [Continuum documentation](http://docs.continuum.io/anaconda/install.html) if there is a problem with installation. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ElMTEdMEJlHm",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "## Task 2: Create Anaconda virtual environments\n",
        "\n",
        "We will use TensorFlow in this unit and TensorFlow may require a Python version different from the the Anaconda default.\n",
        "\n",
        "You can check your current Python version with following command in the Anaconda Prompt.\n",
        "\n",
        "```shell\n",
        "$ python --version\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "If you need to install the different Python version to work with TensorFlow, you should create a virtual ennironment for that Python version. \n",
        "\n",
        "Still in the Anaconda Prompt, run\n",
        "\n",
        "```shell\n",
        "$ conda create --name tfenv python=3.7\n",
        "```\n",
        "\n",
        "Then every time we need to use Python 3.7, we can activate that environment by running\n",
        "\n",
        "```shell\n",
        "$ conda activate tfenv\n",
        "```\n",
        "\n",
        "It is a good practice to keep separate Anaconda environments for different projects."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3yRTylf5JlHn",
        "colab_type": "text"
      },
      "source": [
        "## Task 3: Install Jupyter\n",
        "\n",
        "You will use IPython Notebook (aka Jupyter Notebook) for most of the practicals in this unit. In this unit, you are recommended to use [JupyterLab](http://jupyterlab.readthedocs.io/en/stable/), which was designed to replace the Jupyter Notebook. \n",
        "\n",
        "To install JupyterLab, you run the following conda command:\n",
        "\n",
        "```shell\n",
        "$ conda install jupyterlab\n",
        "```\n",
        "\n",
        "You may also like to install useful JupyterLab extensions. In particular, you may follow the note *Building TOC extension for Jupyter Lab* in the resources folder to install the table-of-contents extension.\n",
        "\n",
        "### Start Jupyter\n",
        "\n",
        "To start Jupyter, cd the directory that contains your notebook (say, DIR).\n",
        "```shell\n",
        "$ cd DIR\n",
        "```\n",
        "\n",
        "and run the following command:\n",
        "```shell\n",
        "$ jupyter lab\n",
        "```\n",
        "\n",
        "Alternatively, you can specify the notebook directory (DIR):\n",
        "```shell\n",
        "$ jupyter lab --notebook-dir=DIR\n",
        "```\n",
        "  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qy0bbjWzJlHo",
        "colab_type": "text"
      },
      "source": [
        "## Task 4: Install TensorFlow\n",
        "\n",
        "Install TensorFlow with CPU only :\n",
        "```shell\n",
        "$ conda install tensorflow\n",
        "```\n",
        "\n",
        "Install TensorFlow with GPU support:\n",
        "```shell\n",
        "$ conda install tensorflow-gpu\n",
        "```\n",
        "\n",
        "If you want to install Tensorflow on other configurations, you can follow the instructions in [this guide](https://www.tensorflow.org/install/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SMrwXxlJJlHq",
        "colab_type": "text"
      },
      "source": [
        "### Testing the installation\n",
        "\n",
        "Import TensorFlow and print out the version\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u4WXCciXJlHr",
        "colab_type": "code",
        "outputId": "8ce5026f-d810-43a0-fe28-218d98a35bdd",
        "colab": {}
      },
      "source": [
        "import tensorflow as tf\n",
        "print(tf.__version__)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.0.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V6tLYuLZJlHx",
        "colab_type": "text"
      },
      "source": [
        "### Other packages\n",
        "\n",
        "In addition to TensorFlow, we also install `tensorflow-datasets` to access readily available datasets.\n",
        "\n",
        "```shell\n",
        "$ conda install tensorflow-datasets\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ojZIANhCJlHy",
        "colab_type": "code",
        "outputId": "1d0d36a8-a11f-42b0-ee65-b4c2425e58e0",
        "colab": {}
      },
      "source": [
        "import tensorflow_datasets  as tfds\n",
        "print(tfds.__version__)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1.3.2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GvT-bigZJlH2",
        "colab_type": "text"
      },
      "source": [
        "> Following the example above, please install the following conda packages:\n",
        "> - pydot\n",
        "> - graphviz"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QJKzNmilKbKe",
        "colab_type": "text"
      },
      "source": [
        "## Task 5: Use GPU with Google Colab\n",
        "\n",
        "\n",
        "*You may need a Google account to access Google Colab.*\n",
        "\n",
        "\n",
        "GPU is very useful for training deep learning models. If you do not have a computer with a GPU, you can use the free ones provided by Google. \n",
        "\n",
        "> Go through this [Google Colab introduction](https://colab.research.google.com/notebooks/intro.ipynb#).\n",
        "\n",
        "For using TensorFlow 2, go through [this notebook](https://colab.research.google.com/notebooks/tensorflow_version.ipynb).\n",
        "\n",
        "It is important to understand how to enable GPU in Google Colab, which is explained [here](https://colab.research.google.com/notebooks/gpu.ipynb). In your Colab notebook, select Edit→Notebook Settings and choose **GPU** in the *Hardware accelerator* dropdown menu. You may need to restart your runtime (via the shortcut `Ctrl+M .`).\n",
        "\n",
        "> Confirm GPU is enabled for your notebook.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IAM5aOWGQID9",
        "colab_type": "code",
        "outputId": "d8f1e805-1035-4d69-ee86-998db7d2d02f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "%tensorflow_version 2.x\n",
        "import tensorflow as tf\n",
        "device_name = tf.test.gpu_device_name()\n",
        "if device_name != '/device:GPU:0':\n",
        "  raise SystemError('GPU device not found')\n",
        "print('Found GPU at: {}'.format(device_name))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "TensorFlow 2.x selected.\n",
            "Found GPU at: /device:GPU:0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kOq0220PRb4V",
        "colab_type": "code",
        "outputId": "a22fe2e3-874b-46e9-8b0b-f99be71e6f91",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        " %%time\n",
        " with tf.device('/device:GPU:0'):\n",
        "    random_image = tf.random.normal((10000, 10000, 3))\n",
        "    tf.math.reduce_sum(random_image)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 892 µs, sys: 40.9 ms, total: 41.8 ms\n",
            "Wall time: 46.8 ms\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VotWUGjpRS_1",
        "colab_type": "code",
        "outputId": "3069f6b4-d425-4f76-a5ba-4a44d96a9386",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        " %%time\n",
        " with tf.device('/cpu:0'):\n",
        "    random_image = tf.random.normal((10000, 10000, 3))\n",
        "    tf.math.reduce_sum(random_image)\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 9.33 s, sys: 795 ms, total: 10.1 s\n",
            "Wall time: 5.2 s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "odNES2IjJlH8",
        "colab_type": "text"
      },
      "source": [
        "## **Review**: Scipy — Scientific Computing Tools for Python<!--span style=\"color:#0b486b\">3. Scipy: Scientific Computing Tools for Python</span-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5RKSyAZ-JlH-",
        "colab_type": "text"
      },
      "source": [
        "[SciPy](https://www.scipy.org) (pronounced “Sigh Pie”) is a Python-based ecosystem of open-source software for mathematics, science, and engineering. In particular, the SciPy ecosystem these are some of the core packages:\n",
        "\n",
        "- Numpy: a base N-dimensional array package\n",
        "- Matplotlib: a package that allows you to create charts and plots from data.\n",
        "- Pandas: tools and data structures to organize and analyze your data.\n",
        "- SciPy library: a fundamental library for scientific computing such as optimization.\n",
        "\n",
        "All of these packages are pre-installed when you install the Anaconda. You can check the availibility and versions of above packages as follows:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "idP2UAnHJlH_",
        "colab_type": "code",
        "outputId": "0aa5f553-6c76-4629-d963-64d149552ccf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        }
      },
      "source": [
        "# scipy\n",
        "import scipy\n",
        "print(f'The scipy version is {scipy.__version__}')\n",
        "\n",
        "# numpy\n",
        "import numpy\n",
        "print(f\"The numpy version is {numpy.__version__}.\")\n",
        "\n",
        "# matplotlib\n",
        "import matplotlib\n",
        "print(f'The matplotlib version is {matplotlib.__version__}')\n",
        "\n",
        "# pandas\n",
        "import pandas\n",
        "print(f'The pandas version is {pandas.__version__}')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The scipy version is 1.4.1\n",
            "The numpy version is 1.17.5.\n",
            "The matplotlib version is 3.1.3\n",
            "The pandas version is 0.25.3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XNIRludKJlID",
        "colab_type": "text"
      },
      "source": [
        "We now briefly go through these packages to know NumPy, Matplotlib and Pandas to read and write machine learning Python\n",
        "scripts."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RNid-J9wJlIE",
        "colab_type": "text"
      },
      "source": [
        "## Numpy<!--3.1 Numpy-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GmON5qPYJlIF",
        "colab_type": "text"
      },
      "source": [
        "[Numpy](http://www.numpy.org/) is the core library for scientific computing in Python. It provides a high-performance multidimensional array object, and tools for working with these arrays. Numpy is a pre-built package included in Anaconda 3. You only need to import to use the package."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wf-uUMmkJlIG",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "###  Arrays<!--3.1.1 Arrays-->\n",
        "A numpy array is a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. The number of dimensions is the <em>rank</em> of the array; the <em>shape</em> of an array is a tuple of integers giving the size of the array along each dimension.\n",
        "You can initialize numpy arrays from nested Python lists or use pre-defined functions to create arrays"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FryTYaQWJlIH",
        "colab_type": "code",
        "outputId": "94e92374-e187-40b3-8a17-45b831e379ca",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 425
        }
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "\n",
        "a = np.array([1, 2, 3])   # Create a rank 1 array\n",
        "b = np.array([[1,2,3],[4,5,6]])    # Create a rank 2 array\n",
        "\n",
        "print(\"Arrays are created from nested Python lists\\n\")\n",
        "\n",
        "print(f\"The data type of a is {type(a)}\")          \n",
        "print(f\"The shape of a is {a.shape}.\")    \n",
        "\n",
        "print(f\"The shape of b is {b.shape}.\")               \n",
        "\n",
        "print(\"\\nArrays are created with pre-defined functions\\n\")\n",
        "\n",
        "c = np.zeros((3,2))   # Create an array of all zeros\n",
        "print(f\"\"\"An all-zero array \n",
        "{c}\"\"\")\n",
        "         \n",
        "\n",
        "d = np.ones((3,2))    # Create an array of all ones\n",
        "print(f\"\"\"\n",
        "An all ones array\n",
        "{d}\"\"\")\n",
        "\n",
        "\n",
        "e = np.full((2,2), 7)  # Create a constant array\n",
        "print(f\"\"\"\n",
        "A constant\n",
        "{e}\"\"\")\n",
        "\n",
        "f = np.eye(2)         # Create a 2x2 identity matrix\n",
        "print(f\"\"\"\n",
        "A 2x2 identity  array\n",
        "{f}\"\"\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Arrays are created from nested Python lists\n",
            "The data type of a is <class 'numpy.ndarray'>\n",
            "The shape of a is (3,).\n",
            "The shape of b is (2, 3).\n",
            "\n",
            "Arrays are created with pre-defined functions\n",
            "\n",
            "An all-zero array \n",
            "[[0. 0.]\n",
            " [0. 0.]\n",
            " [0. 0.]]\n",
            "\n",
            "An all ones array\n",
            "[[1. 1.]\n",
            " [1. 1.]\n",
            " [1. 1.]]\n",
            "\n",
            "A constant\n",
            "[[7 7]\n",
            " [7 7]]\n",
            "\n",
            "A 2x2 identity  array\n",
            "[[1. 0.]\n",
            " [0. 1.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FIJPw60QJlIM",
        "colab_type": "text"
      },
      "source": [
        "###  Array indexing<!--3.1.2  Array indexing-->\n",
        "Numpy offers several ways to index into arrays.\n",
        "\n",
        "<strong>Slicing:</strong>Numpy arrays can be sliced. Since arrays may be multidimensional, you must specify a slice for each dimension of the array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eKtqKUO_JlIN",
        "colab_type": "code",
        "outputId": "99f5f83a-73b7-455e-c9d9-be0902337157",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        }
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
        "\n",
        "print(f'a is {a}')\n",
        "\n",
        "# Slice the subarray consisting of the first 2 rows and columns 1 and 2; \n",
        "b = a[:2, 1:3]\n",
        "\n",
        "print(f'b is {b}')\n",
        "\n",
        "# A slice of an array is a view into the same data, so modifying it\n",
        "# will modify the original array.\n",
        "\n",
        "print(a[0, 1])   \n",
        "b[0, 0] = 77     # b[0, 0] is the same piece of data as a[0, 1]\n",
        "print(a[0, 1])   "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a is [[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]]\n",
            "b is [[2 3]\n",
            " [6 7]]\n",
            "2\n",
            "77\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tsFQoHXbJlIR",
        "colab_type": "text"
      },
      "source": [
        "You can also mix integer indexing with slice indexing to  yield an array of lower rank than the original array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gcN8QqLtJlIS",
        "colab_type": "code",
        "outputId": "8460a70b-9e6d-4a3c-cfbe-6f2586ec48b1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "row_r1 = a[1, :]    # Rank 1 view of the second row of a\n",
        "print(row_r1, row_r1.shape) \n",
        "\n",
        "# We can make the same distinction when accessing columns of an array:\n",
        "col_r1 = a[:, 1]\n",
        "print(col_r1, col_r1.shape)  \n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[5 6 7 8] (4,)\n",
            "[77  6 10] (3,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hTXSAuSTJlIW",
        "colab_type": "text"
      },
      "source": [
        "<strong>Integer array indexing:</strong> When you index into numpy arrays using slicing, the resulting array view will always be a subarray of the original array. In contrast, integer array indexing allows you to construct arbitrary arrays using the data from another array. Here is an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y_dvLV-DJlIX",
        "colab_type": "code",
        "outputId": "4256e197-0ee2-4d9c-bafd-993c414a4a0b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        }
      },
      "source": [
        "print(a) \n",
        "\n",
        "\n",
        "# The returned array will have shape (3,) by choosing elements \n",
        "# at [0,1],[1,1], and [2,0]\n",
        "print(a[[0, 1, 2], [1, 1, 0]])\n",
        "\n",
        "# The above example of integer array indexing is equivalent to this:\n",
        "print(np.array([a[0, 1], a[1, 1], a[2, 0]]))\n",
        "\n",
        "# When using integer array indexing, you can reuse the same\n",
        "# element from the source array:\n",
        "print(a[[0, 0], [1, 1]])  # Prints \"[77 77]\"\n",
        "\n",
        "# Equivalent to the previous integer array indexing example\n",
        "print(np.array([a[0, 1], a[0, 1]])) "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1 77  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]]\n",
            "[77  6  9]\n",
            "[77  6  9]\n",
            "[77 77]\n",
            "[77 77]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vNDTSF2WJlIb",
        "colab_type": "text"
      },
      "source": [
        "<strong>Boolean array indexing:</strong> Boolean array indexing lets you pick out arbitrary elements of an array. Frequently this type of indexing is used to select the elements of an array that satisfy some condition. Here is an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CQTdcG31JlIc",
        "colab_type": "code",
        "outputId": "f737975f-51af-4e7f-ad4a-65f4f8cca047",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        }
      },
      "source": [
        "# Find the elements of a that are bigger than 2;this returns a \n",
        "# numpy array of Booleans of the same shape as a, where each \n",
        "# slot of bool_idx tells whether that element of a is > 5.\n",
        "\n",
        "bool_idx = (a > 5)  \n",
        "print(bool_idx)     \n",
        "\n",
        "# We use boolean array indexing to construct a rank 1 array consisting \n",
        "# of the elements of a corresponding to the True values of bool_idx\n",
        "print(a[bool_idx])  \n",
        "\n",
        "# We can do all of the above in a single concise statement:\n",
        "print(a[a > 5])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[False  True False False]\n",
            " [False  True  True  True]\n",
            " [ True  True  True  True]]\n",
            "[77  6  7  8  9 10 11 12]\n",
            "[77  6  7  8  9 10 11 12]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "byXEz8sLJlIf",
        "colab_type": "text"
      },
      "source": [
        "You can refer to [indexing documentation](https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html) for further details about numpy array indexing."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eQAAEqycJlIg",
        "colab_type": "text"
      },
      "source": [
        "### Array math operations <!--3.1.3  Array math operations-->\n",
        "\n",
        "Basic mathematical functions operate elementwise on arrays, and are available both as operator overloads and as functions in the numpy module:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fjXOTyLzJlIh",
        "colab_type": "code",
        "outputId": "dab0fbb4-feb9-4a8b-9ee4-63174f2e0f59",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 408
        }
      },
      "source": [
        "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
        "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
        "\n",
        "print(\"Elementwise sum; both produce the array\")\n",
        "print(x + y)\n",
        "print(np.add(x, y))\n",
        "\n",
        "print(\"Elementwise difference; both produce the array\")\n",
        "print(x - y)\n",
        "print(np.subtract(x, y))\n",
        "\n",
        "print(\"Elementwise product; both produce the array\")\n",
        "print(x * y)\n",
        "print(np.multiply(x, y))\n",
        "\n",
        "print(\"Elementwise division; both produce the array\")\n",
        "print(x / y)\n",
        "print(np.divide(x, y))\n",
        "\n",
        "print(\"Elementwise square root; produces the array\")\n",
        "print(np.sqrt(x))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Elementwise sum; both produce the array\n",
            "[[ 6.  8.]\n",
            " [10. 12.]]\n",
            "[[ 6.  8.]\n",
            " [10. 12.]]\n",
            "Elementwise difference; both produce the array\n",
            "[[-4. -4.]\n",
            " [-4. -4.]]\n",
            "[[-4. -4.]\n",
            " [-4. -4.]]\n",
            "Elementwise product; both produce the array\n",
            "[[ 5. 12.]\n",
            " [21. 32.]]\n",
            "[[ 5. 12.]\n",
            " [21. 32.]]\n",
            "Elementwise division; both produce the array\n",
            "[[0.2        0.33333333]\n",
            " [0.42857143 0.5       ]]\n",
            "[[0.2        0.33333333]\n",
            " [0.42857143 0.5       ]]\n",
            "Elementwise square root; produces the array\n",
            "[[1.         1.41421356]\n",
            " [1.73205081 2.        ]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ArsDhIqQJlIl",
        "colab_type": "text"
      },
      "source": [
        "To execute matrix multiplication,  We instead use the <kbd>dot</kbd> function to compute inner products of vectors, to multiply a vector by a matrix, and to multiply matrices. <kbd>dot</kbd> is available both as a function in the numpy module and as an instance method of array objects: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LaExrkbjJlIm",
        "colab_type": "code",
        "outputId": "d4d26ccc-0340-442e-8e7e-5bd9b01051a4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        }
      },
      "source": [
        "v = np.array([9,10])\n",
        "w = np.array([11, 12])\n",
        "\n",
        "# Inner product of vectors; both produce 219\n",
        "print(v.dot(w))\n",
        "print(np.dot(v, w))\n",
        "\n",
        "# Matrix / vector product; both produce the rank 1 array [29 67]\n",
        "print(np.matmul(x,v)) # or x @ v\n",
        "\n",
        "\n",
        "# Matrix / matrix product; both produce the rank 2 array\n",
        "print(np.matmul(x, y))\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "219\n",
            "219\n",
            "[29. 67.]\n",
            "[[19. 22.]\n",
            " [43. 50.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w9tPRH6fJlIq",
        "colab_type": "text"
      },
      "source": [
        "Numpy provides many useful functions for performing computations on arrays; Some useful function are <kbd>sum</kbd>, transpose <kbd>T</kbd>. The full list of mathematical functions provided by numpy in [the documentation](https://docs.scipy.org/doc/numpy/reference/routines.math.html). More functions for manipulating arrays can be found in [the documentation](https://docs.scipy.org/doc/numpy/reference/routines.array-manipulation.html)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7j7RYunQJlIr",
        "colab_type": "code",
        "outputId": "fb8b5c8b-01c2-4661-b2a3-e8dd0f716755",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        }
      },
      "source": [
        "x = np.array([[1,2],[3,4]])\n",
        "print(np.sum(x))  # Compute sum of all elements\n",
        "print(np.sum(x, axis=0))  # Compute sum of each column\n",
        "print(np.sum(x, axis=1))  # Compute sum of each row\n",
        "\n",
        "print(x.T)  "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n",
            "[4 6]\n",
            "[3 7]\n",
            "[[1 3]\n",
            " [2 4]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OdiQf5B5JlIv",
        "colab_type": "text"
      },
      "source": [
        "### Broadcasting <!--3.1.4 Broadcasting-->\n",
        "Broadcasting is a powerful mechanism that allows numpy to work with arrays of different shapes when performing arithmetic operations. Frequently we have a smaller array and a larger array, and we want to use the smaller array multiple times to perform some operation on the larger array.\n",
        "For example, suppose that we want to add a constant vector to each row of a matrix. We could do it like this:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8_CamJFJJlIx",
        "colab_type": "code",
        "outputId": "8db9fd72-984e-481d-c2aa-b0f61ead3210",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        }
      },
      "source": [
        "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
        "v = np.array([1, 0, 1])\n",
        "\n",
        "y=x+v\n",
        "print(y)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 2  2  4]\n",
            " [ 5  5  7]\n",
            " [ 8  8 10]\n",
            " [11 11 13]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vP3Q2_jCJlI0",
        "colab_type": "text"
      },
      "source": [
        "Broadcasting two arrays together follows these rules:\n",
        "\n",
        "1. If the arrays do not have the same rank, prepend the shape of the lower rank array with 1s until both shapes have the same length.\n",
        "2. The two arrays are said to be compatible in a dimension if they have the same size in the dimension, or if one of the arrays has size 1 in that dimension.\n",
        "3. The arrays can be broadcast together if they are compatible in all dimensions.\n",
        "4. After broadcasting, each array behaves as if it had shape equal to the elementwise maximum of shapes of the two input arrays.\n",
        "5. In any dimension where one array had size 1 and the other array had size greater than 1, the first array behaves as if it were copied along that dimension\n",
        "\n",
        "More explanation for broadcasting arrays can be found in [the documentation](https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p5ZcF0KzJlI1",
        "colab_type": "text"
      },
      "source": [
        "### Numpy Excercises"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nlKKFaB0JlI2",
        "colab_type": "text"
      },
      "source": [
        "**<span style=\"color:red\"> Exercise 1: </span>** : *<span style=\"color:#0b486b\"> Create a vector with values ranging from 10 to 20 (inclusive) then reverse that vector (the first element becomes the last)  </span>*.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DW5R3Ii7JlI3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# enter your own codes here\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AdkHzRZiJlI7",
        "colab_type": "text"
      },
      "source": [
        "**<span style=\"color:red\"> Exercise 2: </span>** : *<span style=\"color:#0b486b\"> Create random vector of size 10, print the maximum value and its index, and replace that value by 0  </span>*.\n",
        "Hint: Using *max* and *argmax* functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aIaMkXK9JlI8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# enter your own codes here\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YFqUm6ckJlI_",
        "colab_type": "text"
      },
      "source": [
        "**<span style=\"color:red\"> Exercise 3: </span>** : *<span style=\"color:#0b486b\"> Given two vectors: ages and heights as follows:   </span>*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RxQ4T7ySJlI_",
        "colab_type": "code",
        "outputId": "0257bd84-0d2b-4ab5-9318-fd70d09b44da",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "ages = np.random.randint(low=20, high=60, size=10)\n",
        "heights = np.random.randint(low=150, high=200, size=10)\n",
        "print(ages)\n",
        "print(heights)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[45 36 24 43 31 59 40 39 51 24]\n",
            "[160 193 153 167 180 164 154 193 180 187]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bkqITC_VJlJE",
        "colab_type": "text"
      },
      "source": [
        "*<span style=\"color:#0b486b\"> Order(ascendingly) the people according to their age and print their corresponding heights. </span>* Hints: using *argsort* function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dj9Knfg7JlJF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# enter your own codes here\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UPbsJGtZJlJJ",
        "colab_type": "text"
      },
      "source": [
        "## Matplotlib <!--3.2 Matplotlib-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wKj-v-NTJlJK",
        "colab_type": "text"
      },
      "source": [
        "Matplotlib can be used for creating plots and charts. The library is generally used as follows:\n",
        "- Call a plotting function with some data (e.g. .plot()).\n",
        "- Call many functions to setup the properties of the plot (e.g. labels and colors).\n",
        "- Make the plot visible (e.g. .show()).\n",
        "\n",
        "You can create a simple line plot from one dimensional data as follows:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zbDTR9IjJlJL",
        "colab_type": "code",
        "outputId": "aa29ac78-fcd2-49c2-ff4b-5654cf58c53c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 296
        }
      },
      "source": [
        "%matplotlib inline \n",
        "\n",
        "# basic line plot\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy\n",
        "myarray = numpy.array([1, 2, 3])\n",
        "plt.plot(myarray)\n",
        "plt.xlabel('X axis')\n",
        "plt.ylabel('Y axis')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Y axis')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0\ndHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3dd5hU9fn+8fdD772XZUFAOoorWLBg\nBTtqEkvUWIIxJtEUBcWCSqxJjIkaREUlsUQpiogoKooNFBB2YWlLkd7b0rc8vz/m8PuOm1nYlT0z\nu7P367rmYuZzPmfm3rPDPnvmnH2OuTsiIiIFVUh0ABERKZ1UIEREJCYVCBERiUkFQkREYlKBEBGR\nmColOkBJatSokaempiY6hohImTFr1qzN7t441rKkKhCpqanMnDkz0TFERMoMM/u+sGX6iElERGJS\ngRARkZhUIEREJCYVCBERiUkFQkREYgqtQJhZNTP7xszmmtl8M3sgxpyqZvZfM8sysxlmlhq17K5g\nfJGZnRtWThERiS3MPYj9wBnu3hM4BuhvZicUmHMjsM3d2wNPAo8BmFkX4AqgK9AfeNbMKoaYVURE\nCgitQHjEruBh5eBWsLf4xcArwf0xwJlmZsH4G+6+392XA1lA77CyioiUVd+u2MqIz5aG8tyhHoMw\ns4pmNgfYCExx9xkFprQEVgG4ey6wA2gYPR5YHYzFeo1BZjbTzGZu2rSppL8EEZFSadf+XO57Zx4/\nGfE1r81YyZ4DuSX+GqEWCHfPc/djgFZAbzPrFsJrjHT3NHdPa9w45l+Li4gklc8Wb+LcJ6fx7+nf\nc/3Jqbx/2ynUqFLyjTHi0mrD3beb2VQixxPmRS1aA7QGVptZJaAusCVq/KBWwZiISLm1bfcBHnov\nk3Gz19C+SS3G/OokjmtTP7TXC/MspsZmVi+4Xx04G1hYYNoE4Lrg/uXAJx65BuoE4IrgLKe2QAfg\nm7CyioiUZu7OpIx1nP3kZ0yYs5bfntGe937XN9TiAOHuQTQHXgnOPqoAvOnuE83sQWCmu08AXgT+\nbWZZwFYiZy7h7vPN7E0gE8gFbnX3vBCzioiUSht37uPed+bxwfwNdG9Zl9E39KFLizpxeW2L/MKe\nHNLS0lzdXEUkGbg7b81azfCJmezPzef3Z3fkpr5tqVSxZD/4MbNZ7p4Wa1lStfsWEUkGq7bu4a5x\nGXyRtZneqQ149LLutGtcK+45VCBEREqJvHznla9W8MQHi6hYwXjokm5c3TuFChUsIXlUIERESoEl\nG7IZPDad2Su3c/rRjXl4YHda1Kue0EwqECIiCZSTl8+IT5fyz0+yqFm1In//2TFcfEwLIk0lEksF\nQkQkQTJW7+COMXNZuD6bC3o0Z9hFXWlUq2qiY/1/KhAiInG2LyePJz9azPPTltGoVlVGXnMc53Rt\nluhY/0MFQkQkjqYv28Jd4zJYvnk3V/ZuzZABnalbvXKiY8WkAiEiEgfZ+3J49P2FvDpjJSkNavDa\nTX04qX2jRMc6JBUIEZGQTV24kbvHZ7Bh5z5u6tuWP5zTMZTmeiWt9CcUESmjtu4+wIPvzuftOWvp\n0KQWz95yEsemhNs/qSSpQIiIlDB3Z2L6OoZNmM+OvTncdmYHft3vKKpWKlsXxlSBEBEpQRt27mPo\n+Hl8tGADPVrV5dVf9qFTs/g01ytpKhAiIiXA3fnvt6v486QF5OTlM/S8zlx/cmqJN9eLJxUIEZEj\n9P2W3QwZm8HXy7ZwQrsGPHppD1Ib1Ux0rCOmAiEi8iPl5Tsvfbmcv3y4iMoVKvDwwO5ccXzrhDXX\nK2kqECIiP8Ki9dncOTaduau2c2anJgwf2I3mdRPbXK+khVYgzKw1MBpoCjgw0t2fKjDnDuDqqCyd\ngcbuvtXMVgDZQB6QW9gFLURE4ulAbj7PfprFM1OzqF2tMk9dcQwX9SwdzfVKWph7ELnAH919tpnV\nBmaZ2RR3zzw4wd2fAJ4AMLMLgd+7+9ao5+jn7ptDzCgiUmRzVm1n8Jh0Fm3I5uJjWnDfBV1oWIqa\n65W00AqEu68D1gX3s81sAdCSyHWmY7kSeD2sPCIiP9beA3n8bcoiXvxiOU1qV+PF69I4s3PTRMcK\nXVyOQZhZKnAsMKOQ5TWA/sBvooYd+NDMHHjO3UcWsu4gYBBASkpKyYUWEQG+WrqZIWMzWLl1D1f1\nSWHIgE7UqVY6m+uVtNALhJnVAsYCt7v7zkKmXQh8WeDjpb7uvsbMmgBTzGyhu08ruGJQOEYCpKWl\neQnHF5Fyaue+HB6ZtJDXv1lJm4Y1eP2XJ3DiUQ0THSuuQi0QZlaZSHF41d3HHWLqFRT4eMnd1wT/\nbjSz8UBv4H8KhIhISfsocwND385gU/Z+Bp3ajt+f1ZHqVcpWm4ySEOZZTAa8CCxw978dYl5d4DTg\n51FjNYEKwbGLmsA5wINhZRURAdiyaz8PvJvJhLlr6dSsNiOvSaNn63qJjpUwYe5BnAxcA2SY2Zxg\n7G4gBcDdRwRjA4EP3X131LpNgfHBaWOVgNfcfXKIWUWkHHN3Jsxdy7AJ89m1P5ffn9WRW04/iiqV\nym6bjJIQ5llMXwCHPTHY3V8GXi4wtgzoGUowEZEoa7fv5Z635/HJwo0c07oej1/eg45Nayc6Vqmg\nv6QWkXIpP995/duVPDJpIXn5zr0XdOEXJ6VSMUnaZJQEFQgRKXeWb97NkLHpzFi+lZPbN+SRgT1I\naVgj0bFKHRUIESk3cvPyGfXlcv764WKqVKrAY5d156dprZOyTUZJUIEQkXJhwbqdDB6bTvrqHZzd\npSnDL+lG0zrVEh2rVFOBEJGktj83j2c+yeLZT5dSt3plnr7qWM7v3lx7DUWgAiEiSWv2ym0MHpPO\nko27uPTYltx7QRfq16yS6FhlhgqEiCSdPQdy+csHi3npq+U0r1ONl64/nn5HN0l0rDJHBUJEksqX\nWZsZMi6dVVv3cs0Jbbiz/9HULifN9UqaCoSIJIUde3N4+L0F/HfmKto2qsl/B51An3blq7leSVOB\nEJEy74P567n37Xls2X2AX512FLef1YFqlctfc72SpgIhImXWpuz9DJswn/cy1tG5eR1evO54ureq\nm+hYSUMFQkTKHHdn/HdreHBiJnv25/Gnczpy82lHUbli+W6uV9JUIESkTFmzfS9Dx2fw6aJN9EqJ\nNNdr30TN9cKgAiEiZUJ+vvPqjO959P2FODDswi5cc6Ka64VJBUJESr2lm3YxZGw6367YxikdGvHw\nwO60bqDmemFTgRCRUis3L5+Rny/j7x8toVqlCjxxeQ8uP66V2mTESWhHdMystZlNNbNMM5tvZrfF\nmHO6me0wsznB7b6oZf3NbJGZZZnZkLByikjpNH/tDi559ksen7yIM45uwkd/OI2fqPNqXIW5B5EL\n/NHdZ5tZbWCWmU1x98wC8z539wuiB8ysIvAMcDawGvjWzCbEWFdEksy+nDz++ckSRny2jPo1qvCv\nq3sxoHvzRMcql8K85Og6YF1wP9vMFgAtgaL8kO8NZAWXHsXM3gAuLuK6IlJGzfp+K3eOSWfppt1c\n1qsV917QmXo11FwvUeJyDMLMUoFjgRkxFp9oZnOBtcCf3H0+kUKyKmrOaqBPIc89CBgEkJKSUnKh\nRSRudu/P5YkPFvHK1ytoUbc6r9zQm9M6Nk50rHIv9AJhZrWAscDt7r6zwOLZQBt332Vm5wFvAx2K\n8/zuPhIYCZCWluYlEFlE4mja4k3cNS6DtTv2cu0JbbijfydqVdX5M6VBqN8FM6tMpDi86u7jCi6P\nLhjuPsnMnjWzRsAaoHXU1FbBmIgkie17DjD8vQWMmbWado1r8ubNJ3J8aoNEx5IooRUIi5xq8CKw\nwN3/VsicZsAGd3cz603krKotwHagg5m1JVIYrgCuCiuriMTX+xnruPed+Wzbc4Bb+x3Fb89Qc73S\nKMw9iJOBa4AMM5sTjN0NpAC4+wjgcuAWM8sF9gJXuLsDuWb2G+ADoCIwKjg2ISJl2Mbsfdz/znze\nn7eeri3q8MoNx9O1hZrrlVYW+XmcHNLS0nzmzJmJjiEiBbg7Y2atZvh7C9ibk8ftZ3Xgl6e0U3O9\nUsDMZrl7WqxlOhIkIqFatXUPd4/P4PMlmzk+tT6PXtaDoxrXSnQsKQIVCBEJRX6+M/rrFTz+wSIM\nePDirvy8TxsqqLlemaECISIlLmtjNoPHZjDr+22c2rExDw/sRqv6aq5X1qhAiEiJycnLZ+S0ZTz1\n0RJqVK3IX3/Sk0t7tVT/pDJKBUJESsS8NTu4c0w6met2cn735gy7qCuNa1dNdCw5AioQInJE9uXk\n8dTHSxg5bRkNalZhxM+Po3+3ZomOJSVABUJEfrRvlm9lyNh0lm3ezU/TWjH0vC7UrVE50bGkhKhA\niEix7dqfy2PvL+Tf07+nVf3q/OfGPvTt0CjRsaSEqUCISLFMXbSRoeMyWLdzH9efnMqfzjmammqu\nl5T0XRWRItm2+wAPTcxk3HdraN+kFmN+dRLHtamf6FgSIhUIETkkd2dSxnrunzCP7Xty+N0Z7bn1\njPZUraTmeslOBUJECrVh5z7ufXseH2ZuoHvLuoy+oQ9dWtRJdCyJExUIEfkf7s6bM1cx/L0FHMjN\n564Bnbixb1sqqbleuaICISI/sHLLHu4an86XWVvo3bYBj17anXZqrlcuqUCICAB5+c7LX63gLx8s\nomIFY/gl3biqd4qa65VjYV5RrjUwGmgKODDS3Z8qMOdqYDBgQDZwi7vPDZatCMbygNzC+pWLyJFb\nsiGbO8em893K7fQ7ujF/HtidFvWqJzqWJFiYexC5wB/dfbaZ1QZmmdkUd8+MmrMcOM3dt5nZAGAk\n0CdqeT933xxiRpFy7UBuPiM+W8o/P1lCraqV+PvPjuHiY1qouZ4AIRYId18HrAvuZ5vZAqAlkBk1\n56uoVaYDrcLKIyI/NHfVdgaPTWfh+mwu7NmC+y/sQqNaaq4n/ycuxyDMLBU4FphxiGk3Au9HPXbg\nQzNz4Dl3H1nIcw8CBgGkpKSURFyRpLb3QB5//2gxz3++jMa1q/L8tWmc3aVpomNJKRR6gTCzWsBY\n4HZ331nInH5ECkTfqOG+7r7GzJoAU8xsobtPK7huUDhGQuSa1CX+BYgkkenLtjBkbDortuzhyt6t\nGTKgM3Wrq7mexBZqgTCzykSKw6vuPq6QOT2AF4AB7r7l4Li7rwn+3Whm44HewP8UCBE5vOx9OTz6\n/kJenbGSlAY1eO2mPpzUXs315NDCPIvJgBeBBe7+t0LmpADjgGvcfXHUeE2gQnDsoiZwDvBgWFlF\nktknCzcwdPw8Nuzcx0192/KHczpSo4rOcJfDC/NdcjJwDZBhZnOCsbuBFAB3HwHcBzQEng3Omjh4\nOmtTYHwwVgl4zd0nh5hVJOls2bWfBydm8s6ctXRsWotnrz6JY1PUXE+KLsyzmL4g8vcNh5pzE3BT\njPFlQM+QookkNXfn3fR1DJswn+x9Odx2Zgdu7deeKpXUJkOKR/uZIklk/Y593PN2Bh8t2EjPVnV5\n7PI+dGqm5nry46hAiCQBd+eNb1fx8HsLyMnPZ+h5nbmhb1sqqk2GHAEVCJEybsXm3dw1LoOvl23h\nhHYNePTSHqQ2qpnoWJIEVCBEyqi8fGfUF8v565RFVK5QgUcu7c4Vx7dWmwwpMSoQImXQovXZ3Dlm\nLnNX7+Cszk0Yfkl3mtWtluhYkmRUIETKkAO5+TwzNYtnP82idrXK/OPKY7mwR3PtNUgoVCBEyog5\nq7Zz55i5LN6wi4uPacH9F3alQc0qiY4lSeywBcLMfgJMDv6q+R6gFzDc3WeHnk5E2HMgl799uJhR\nXy6nSe1qvHhdGmd2VnM9CV9R9iDudfe3zKwvcBbwBPAvfnjdBhEJwVdZmxkyLoOVW/dwdZ8UBg/o\nRJ1qaq4n8VGUApEX/Hs+kavCvWdmw0PMJFLu7dibwyOTFvDGt6tIbViDNwadwAntGiY6lpQzRSkQ\na8zsOeBs4DEzqwrob/ZFQjIlcwP3vJ3Bpuz93HxqO24/qyPVq1RMdCwph4pSIH4K9Af+4u7bzaw5\ncEe4sUTKn8279jNswnwmpq+jU7PaPH9tGj1a1Ut0LCnHCi0QZlYnuMBPNeDTYKwBsB+YGZd0IuWA\nu/POnLU88O58du3P5Q9nd+RXpx2l5nqScIfag3gNuACYReTyn9EnWjvQLsRcIuXC2u17GTo+g6mL\nNnFM63o8fnkPOjatnehYIsAhCoS7XxD82zZ+cUTKh/x859VvVvLY+wvJy3fuvaALvzgpVc31pFQp\nyt9B3OjuL0Y9rgjc4+4PhJpMJEkt37ybwWPT+Wb5Vk5u35BHBvYgpWGNRMcS+R9F+ZDzTDObZGbN\nzawbMB047D6wmbU2s6lmlmlm883sthhzzMz+YWZZZpZuZr2ill1nZkuC23XF+qpESqHcvHxGfLaU\n/n+fxoJ1O3n8sh7858Y+Kg5Sah12D8LdrzKznwEZwG7gKnf/sgjPnQv80d1nm1ltYJaZTXH3zKg5\nA4AOwa0PwR/gBQfD7wfSiBzvmGVmE9x9W3G+OJHSInPtTgaPTSdjzQ7O7tKU4Zd0o2kdNdeT0q0o\nHzF1AG4DxgKdgWvM7Dt333Oo9dx9HbAuuJ9tZguAlkB0gbgYGO3uDkw3s3rBabSnA1PcfWuQYQqR\nU21fL+bXJ5JQ+3PzePqTLP716VLq1ajMM1f14rzuzdRcT8qEovwdxLvAre7+sUXe1X8AvgW6FvVF\nzCwVOBaYUWBRS2BV1OPVwVhh47GeexAwCCAlJaWokURCN+v7bQwem07Wxl0MPLYl913Qhfpqridl\nSFEKRO/g7yEIftP/q5m9W9QXMLNaRPY+bj/4PCXJ3UcCIwHS0tK8pJ9fpLh278/lLx8u4uWvVtC8\nTjVeuv54+h3dJNGxRIqtKMcgdgYHp7sQ+aO5gxYfbl0zq0ykOLzq7uNiTFkDtI563CoYW0PkY6bo\n8U8P93oiifb5kk3cNS6D1dv2cu2JbbizfydqVVVXfSmbinIM4n4iP6y7AJOIHFj+Ahh9mPUMeBFY\n4O5/K2TaBOA3ZvYGkYPUO9x9nZl9ADxsZvWDeecAdx3+yxFJjB17cvjzpEzenLmato1q8ubNJ9K7\nbYNExxI5IkX51eZyoCfwnbtfb2ZNgf8UYb2TgWuADDObE4zdDaQAuPsIIgXnPCAL2ANcHyzbamYP\nETnWAfDgwQPWIqXN5HnrufedeWzdfYBbTj+K287sQLXKaq4nZV9RCsRed883s1wzqwNs5IcfC8Xk\n7l/ww/YcseY4cGshy0YBo4qQTyQhNmVHmuu9l7GOzs3rMOq64+neqm6iY4mUmKIUiJlmVg94nkhf\npl3A16GmEinF3J1xs9fw4MRM9h7I445zj2bQqe2oXFHN9SS5FOUg9a+DuyPMbDJQx93Tw40lUjqt\n3raHu8fPY9riTRzXpj6PXdaD9k1qJTqWSCiKdXqFu68IKYdIqZaf7/xnxvc89v5CHBh2YReuPTGV\nCmquJ0lM59+JHMbSTbsYMjadb1ds45QOjXh4YHdaN1D/JEl+h7pg0CTg19prkPIqJy+f5z9fxt8/\nWkK1ShV44vIeXH5cK7XJkHLjUHsQLwEfmtkrwOPunhOnTCIJN2/NDgaPTWf+2p3079qMBy/pSpPa\naq4n5cuhLhj0lpm9D9xL5EymfwP5UcsL++M3kTJrX04e//h4Cc9NW0b9GlX419W9GNC9eaJjiSTE\n4Y5BHCDS4rsqkWtA5B96ukjZNXPFVu4cm86yTbu5/LhW3HN+Z+rVUHM9Kb8OdQyiP/A3Iu0weh2u\nvbdIWbVrfy5PTF7I6Onf06JudUbf0JtTOzZOdCyRhDvUHsRQ4CfuPj9eYUTi7bPFm7h7XAZrd+zl\nuhNTuePco6mp5noiwKGPQZwSzyAi8bR9zwEemriAsbNX065xTd66+UTSUtVcTySaflWScmdSxjru\ne2ce2/bkcGu/o/jtGWquJxKLCoSUGxt37uO+d+Yzef56uraowys39KZrCzXXEymMCoQkPXfnrVmr\nGT4xk325+Qzu34lfntKWSmquJ3JIKhCS1FZt3cPd4zP4fMlmjk+tz6OX9eCoxmquJ1IUKhCSlPLy\nndFfr+CJDxZhwEMXd+XqPm3UXE+kGEIrEGY2CrgA2Oju3WIsvwO4OipHZ6BxcDW5FUA2kAfkunta\nWDkl+WRtzObOMenMXrmd0zo25s8Du9GqvprriRRXmHsQLwNPU8i1q939CeAJADO7EPh9gcuK9nP3\nzSHmkySTk5fPc58t5R8fZ1GjakX+9tOeDDy2pZrrifxIoRUId59mZqlFnH4l8HpYWST5ZazewR1j\n5rJwfTbn92jOsAu70rh21UTHEinTEn4MwsxqAP2B30QNO5FOsg485+4jD7H+IGAQQEpKSphRpRTa\nl5PH3z9awvOfL6NBzSo8d81xnNu1WaJjiSSFhBcI4ELgywIfL/V19zVm1gSYYmYL3X1arJWD4jES\nIC0tzcOPK6XFjGVbGDIug+Wbd/OztNbcfV5n6taonOhYIkmjNBSIKyjw8ZK7rwn+3Whm44HeQMwC\nIeVP9r4cHp+8iH9P/55W9avznxv70LdDo0THEkk6CS0QZlYXOA34edRYTaCCu2cH988BHkxQRCll\npi7cyNDxGazbuY8bTm7Ln87tSI0qpeH3HJHkE+Zprq8DpwONzGw1cD9QGcDdRwTTBgIfuvvuqFWb\nAuODM08qAa+5++SwckrZsHX3AR6amMn479bQoUktxvzqJI5rUz/RsUSSWphnMV1ZhDkvEzkdNnps\nGdAznFRS1rg772Ws4/535rNjbw6/O6M9t57RnqqV1FxPJGzaN5dSa8POfdzz9jymZG6ge8u6/Oem\nPnRuXifRsUTKDRUIKXXcnTdnrmL4ews4kJvPXQM6cWNfNdcTiTcVCClVVm7Zw5Bx6Xy1dAu92zbg\nsct60LZRzUTHEimXVCCkVMjLd176cjl//XAxFSsYwy/pxlW9U9RcTySBVCAk4RZviDTXm7NqO2d0\nasLwS7rRol71RMcSKfdUICRhDuTm869Pl/L01CXUqlqJp644hot6tlBzPZFSQgVCEmLuqu0MHpvO\nwvXZXNizBcMu7ELDWmquJ1KaqEBIXO09kMeTHy3mhc+X0bh2VZ6/No2zuzRNdCwRiUEFQuLm66Vb\nuGtcOiu27OHK3q2567zO1Kmm5noipZUKhIRu574cHn1/Ia/NWElKgxq8dlMfTmqv5noipZ0KhITq\n4wUbGDp+Hhuz9/HLU9ryh7OPpnoVtckQKQtUICQUW3bt54F3M5kwdy1HN63NiGuO45jW9RIdS0SK\nQQVCSpS7M2HuWh54N5PsfTncflYHfn16e6pUUpsMkbJGBUJKzLode7ln/Dw+XriRnq3r8fhlPTi6\nWe1ExxKRH0kFQo5Yfr7zxrereGTSAnLy87nn/M5cf3JbKqpNhkiZFtp+v5mNMrONZjavkOWnm9kO\nM5sT3O6LWtbfzBaZWZaZDQkroxy5FZt3c9UL07l7fAbdWtblg9tP5aZT2qk4iCSBMPcgXgaeBkYf\nYs7n7n5B9ICZVQSeAc4GVgPfmtkEd88MK6gUX25ePqOC5npVKlbg0Uu787PjW6tNhkgSCfOKctPM\nLPVHrNobyAquLIeZvQFcDKhAlBIL1+9k8Jh05q7ewVmdmzD8ku40q1st0bFEpIQl+hjEiWY2F1gL\n/Mnd5wMtgVVRc1YDfQp7AjMbBAwCSElJCTGq7M/N45mpS3l2ahZ1q1fmn1ceywU9mmuvQSRJJbJA\nzAbauPsuMzsPeBvoUNwncfeRwEiAtLQ0L9mIctB3K7cxeGw6izfs4pJjWnDfhV1pULNKomOJSIgS\nViDcfWfU/Ulm9qyZNQLWAK2jprYKxiQB9hzI5a8fLmbUl8tpVqcao36Rxhmd1FxPpDxIWIEws2bA\nBnd3M+tN5IyqLcB2oIOZtSVSGK4ArkpUzvLsy6zNDBmXzqqte7m6TwpDBnSitprriZQboRUIM3sd\nOB1oZGargfuBygDuPgK4HLjFzHKBvcAV7u5Arpn9BvgAqAiMCo5NSJzs2JvDI5MW8Ma3q0htWIM3\nBp3ACe0aJjqWiMSZRX4mJ4e0tDSfOXNmomOUaR/OX889b89j8679/PLUdvz+rI5Uq6zmeiLJysxm\nuXtarGWJPotJSonNu/YzbMJ8Jqavo1Oz2rxwXRo9Wqm5nkh5pgJRzrk7b89ZwwPvZrJnfx5/PLsj\nN592lJrriYgKRHm2dvteho7PYOqiTRybEmmu16GpmuuJSIQKRDmUn++8+s1KHp20gHyH+y7ownUn\npap/koj8gApEObNs0y6GjM3gmxVb6du+EY9c2p3WDWokOpaIlEIqEOVEbl4+L3yxnCenLKZKpQo8\nflkPfpLWSm0yRKRQKhDlQObandw5di7z1uzknC5NeeiSbjSto+Z6InJoKhBJbH9uHk9/ksW/Pl1K\nvRqVeeaqXpzXvZn2GkSkSFQgktSs77cyeGwGWRt3cWmvltx7fhfqq7meiBSDCkSS2b0/lyc+WMQr\nX6+gRd3qvHz98Zx+dJNExxKRMkgFIol8vmQTd43LYPW2vVx7Yhvu7N+JWlX1LRaRH0c/PZLAjj05\nDH8vk7dmraZdo5q8efOJ9G7bINGxRKSMU4Eo4ybPW8+978xj6+4D3HL6Udx2Zgc11xOREqECUUZt\nzN7HsAnzmZSxni7N6/DSL46nW8u6iY4lIklEBaKMcXfGzl7DQxMz2ZuTxx3nHs2gU9tRuaKa64lI\nyVKBKENWb9vD3ePnMW3xJo5rU5/HLutB+ya1Eh1LRJJUmFeUGwVcAGx0924xll8NDAYMyAZucfe5\nwbIVwVgekFvYxSzKi/x859/Tv+exyQsBeOCirlxzQhsqqLmeiIQozD2Il4GngdGFLF8OnObu28xs\nADAS6BO1vJ+7bw4xX5mwdNMuBo9JZ+b32zilQyMeHqjmeiISH6EVCHefZmaph1j+VdTD6UCrsLKU\nRTl5+YyctoynPl5C9coV+ctPenJZr5ZqkyEicVNajkHcCLwf9diBD83MgefcfWRhK5rZIGAQQEpK\nSqgh42Xemh0MHpvO/LU7OWDlY6MAAAvhSURBVK97M4Zd1JUmtdVcT0TiK+EFwsz6ESkQfaOG+7r7\nGjNrAkwxs4XuPi3W+kHxGAmQlpbmoQcO0b6cPP7x8RKem7aM+jWqMOLnvejfrXmiY4lIOZXQAmFm\nPYAXgAHuvuXguLuvCf7daGbjgd5AzAKRLL5dsZXBY9JZtnk3PzmuFfec34W6NSonOpaIlGMJKxBm\nlgKMA65x98VR4zWBCu6eHdw/B3gwQTFDt2t/Lo9PXsjor7+nZb3qjL6hN6d2bJzoWCIioZ7m+jpw\nOtDIzFYD9wOVAdx9BHAf0BB4NjjwevB01qbA+GCsEvCau08OK2cifbZ4E3ePy2Dtjr384qRU7jj3\naGqquZ6IlBJhnsV05WGW3wTcFGN8GdAzrFylwfY9B3hwYibjZq/hqMY1eevmE0lLVXM9ESld9Otq\nHLk7789bz33vzGP7nhx+0689vzmjvZrriUippAIRJxt37uPed+bxwfwNdGtZh1du6E3XFmquJyKl\nlwpEyNydt2atZvjETPbl5jO4fyd+eUpbKqm5noiUcioQIVq1dQ93jcvgi6zN9E5twKOXdaddYzXX\nE5GyQQUiBHn5zuivV/D45EVUMHjo4q5c3UfN9USkbFGBKGFZG7O5c0w6s1du57SOjXn40u60rFc9\n0bFERIpNBaKE5OTlM+LTpfzzkyxqVK3Ikz/rySXHqLmeiJRdKhAlIGP1Du4YM5eF67M5v0dzHrio\nK41qVU10LBGRI6ICcQT25eTx5EeLeX7aMhrVqspz1xzHuV2bJTqWiEiJUIH4kWYs28KQcRks37yb\nn6W15u7zO1O3uprriUjyUIEopux9OTw2eSH/mb6S1g2q8+pNfTi5faNExxIRKXEqEMUwdeFGho7P\nYN3OfdzYty1/PKcjNapoE4pIctJPtyLYuvsAD03MZPx3a+jQpBZjbzmJXin1Ex1LRCRUKhCH4O5M\nTF/HsAnz2bE3h9+d2YFb+x1F1UpqriciyU8FohAbdu5j6Ph5fLRgAz1a1eU/N/Whc/M6iY4lIhI3\nKhAFuDv//XYVf560gAO5+dx9XiduOFnN9USk/An1p56ZjTKzjWY2r5DlZmb/MLMsM0s3s15Ry64z\nsyXB7bowcx60cssern5hBkPGZdCleR0+uP1UBp16lIqDiJRLYe9BvAw8DYwuZPkAoENw6wP8C+hj\nZg2IXKI0DXBglplNcPdtYYTMy3de+nI5f/lwEZUqVODPA7tx5fEpaq4nIuVaqAXC3aeZWeohplwM\njHZ3B6abWT0za07kWtZT3H0rgJlNAfoDr5d0xh17crjupW+Ys2o7Z3Rqwp8HdqN5XTXXExFJ9DGI\nlsCqqMerg7HCxv+HmQ0CBgGkpKQUO0Cd6pVo07AG15+cykU9W6i5nohIINEF4oi5+0hgJEBaWpoX\nd30z46krji3xXCIiZV2ij76uAVpHPW4VjBU2LiIicZLoAjEBuDY4m+kEYIe7rwM+AM4xs/pmVh84\nJxgTEZE4CfUjJjN7ncgB50ZmtprImUmVAdx9BDAJOA/IAvYA1wfLtprZQ8C3wVM9ePCAtYiIxEfY\nZzFdeZjlDtxayLJRwKgwcomIyOEl+iMmEREppVQgREQkJhUIERGJSQVCRERisshx4uRgZpuA73/k\n6o2AzSUYp6QoV/EoV/EoV/EkY6427t441oKkKhBHwsxmuntaonMUpFzFo1zFo1zFU95y6SMmERGJ\nSQVCRERiUoH4PyMTHaAQylU8ylU8ylU85SqXjkGIiEhM2oMQEZGYVCBERCSmpC8QZtbfzBaZWZaZ\nDYmxvKqZ/TdYPiP6EqlmdlcwvsjMzo1zrj+YWaaZpZvZx2bWJmpZnpnNCW4T4pzrF2a2Ker1b4pa\ndp2ZLQlu18U515NRmRab2faoZWFur1FmttHM5hWy3MzsH0HudDPrFbUszO11uFxXB3kyzOwrM+sZ\ntWxFMD7HzGbGOdfpZrYj6vt1X9SyQ74HQs51R1SmecF7qkGwLMzt1drMpgY/C+ab2W0x5oT3HnP3\npL0BFYGlQDugCjAX6FJgzq+BEcH9K4D/Bve7BPOrAm2D56kYx1z9gBrB/VsO5goe70rg9voF8HSM\ndRsAy4J/6wf368crV4H5vwVGhb29guc+FegFzCtk+XnA+4ABJwAzwt5eRcx10sHXAwYczBU8XgE0\nStD2Oh2YeKTvgZLOVWDuhcAncdpezYFewf3awOIY/ydDe48l+x5EbyDL3Ze5+wHgDeDiAnMuBl4J\n7o8BzjQzC8bfcPf97r6cyDUrescrl7tPdfc9wcPpRK6qF7aibK/CnAtMcfet7r4NmAL0T1CuK4HX\nS+i1D8ndpwGHulbJxcBoj5gO1DOz5oS7vQ6by92/Cl4X4vf+Ksr2KsyRvDdLOlc831/r3H12cD8b\nWAC0LDAttPdYsheIlsCqqMer+d+N+//nuHsusANoWMR1w8wV7UYivyEcVM3MZprZdDO7pIQyFSfX\nZcGu7BgzO3hp2FKxvYKP4toCn0QNh7W9iqKw7GFur+Iq+P5y4EMzm2VmgxKQ50Qzm2tm75tZ12Cs\nVGwvM6tB5Ifs2KjhuGwvi3z8fSwwo8Ci0N5joV4wSI6cmf0cSANOixpu4+5rzKwd8ImZZbj70jhF\nehd43d33m9nNRPa+zojTaxfFFcAYd8+LGkvk9irVzKwfkQLRN2q4b7C9mgBTzGxh8Bt2PMwm8v3a\nZWbnAW8DHeL02kVxIfCl//AKl6FvLzOrRaQo3e7uO0vyuQ8l2fcg1gCtox63CsZizjGzSkBdYEsR\n1w0zF2Z2FjAUuMjd9x8cd/c1wb/LgE+J/FYRl1zuviUqywvAcUVdN8xcUa6gwO5/iNurKArLHub2\nKhIz60Hke3ixu285OB61vTYC4ym5j1YPy913uvuu4P4koLKZNaIUbK/Aod5foWwvM6tMpDi86u7j\nYkwJ7z0WxoGV0nIjsoe0jMhHDgcPbHUtMOdWfniQ+s3gfld+eJB6GSV3kLoouY4lclCuQ4Hx+kDV\n4H4jYAkldLCuiLmaR90fCEz3/zsgtjzIVz+43yBeuYJ5nYgcMLR4bK+o10il8IOu5/PDA4jfhL29\nipgrhchxtZMKjNcEakfd/wroH8dczQ5+/4j8oF0ZbLsivQfCyhUsr0vkOEXNeG2v4GsfDfz9EHNC\ne4+V2MYtrTciR/gXE/lhOzQYe5DIb+UA1YC3gv8s3wDtotYdGqy3CBgQ51wfARuAOcFtQjB+EpAR\n/AfJAG6Mc65HgPnB608FOkWte0OwHbOA6+OZK3g8DHi0wHphb6/XgXVADpHPeG8EfgX8KlhuwDNB\n7gwgLU7b63C5XgC2Rb2/Zgbj7YJtNTf4Pg+Nc67fRL2/phNVwGK9B+KVK5jzCyInrkSvF/b26kvk\nGEd61PfqvHi9x9RqQ0REYkr2YxAiIvIjqUCIiEhMKhAiIhKTCoSIiMSkAiEiIjGpQIgUUdBZc3lU\nF8/6wePUEnjur470OURKmk5zFSkGM7sTaO/ug8zsOWCFuz+S6FwiYdAehEjxPAmcYGa3E/kjpr/E\nmmRmbwfN2+YfbOBmZm2CvvyNzKyCmX1uZucEy3YF/zY3s2lR1x04JU5fl8j/0B6ESDFZ5OJRk4Fz\n3H1KIXMauPtWM6sOfAuc5u5bLHKBpXOJ/NV+e3e/OZi/y91rmdkfgWru/mczq0jkmiDZcfnCRArQ\nHoRI8Q0g0pah2yHm/M7MDraLaE3QkdTdXwDqEGmV8KcY630LXG9mw4DuKg6SSCoQIsVgZscAZxNp\nivb74MIsBeecDpwFnOjuPYHviPT8Ong9gYMX56lVcF2PtIk+lUjXzZfN7NoQvgyRIlGBECmi4EqD\n/yLSk38l8ASxj0HUBba5+x4z60SkmBz0GPAqcB/wfIzXaANscPfniTTU61Vwjki8qECIFN0vgZVR\nxx2eBTqb2WkF5k0GKpnZAuBRIh8zEcw7HnjM3V8FDpjZ9QXWPR2Ya2bfAT8DngrlKxEpAh2kFhGR\nmLQHISIiMalAiIhITCoQIiISkwqEiIjEpAIhIiIxqUCIiEhMKhAiIhLT/wPE2geweGhWDgAAAABJ\nRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TznL7CZmJlJO",
        "colab_type": "text"
      },
      "source": [
        "You also can creat a scatter plot from two dimensional data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A8qA7e4bJlJP",
        "colab_type": "code",
        "outputId": "ed520a8a-065f-48ce-8404-64a3d36f9d85",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 296
        }
      },
      "source": [
        "# basic scatter plot\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy\n",
        "x = numpy.array([1, 2, 3])\n",
        "y = numpy.array([2, 4, 6])\n",
        "plt.scatter(x,y)\n",
        "plt.xlabel('X axis')\n",
        "plt.ylabel('Y axis')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Y axis')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nCLmgAtkH6wAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pICjo7SfJlJU",
        "colab_type": "text"
      },
      "source": [
        "There are many more plot types and many more properties that can be set on a plot. See [matplotlib for beginner](http://matplotlib.org/users/beginner.html) and [examples](https://matplotlib.org/examples/index.html) to learn more about the Matplotlib API."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OFd1iQ14JlJV",
        "colab_type": "text"
      },
      "source": [
        "### Matplotlib Excercises"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mN5VsU21JlJW",
        "colab_type": "text"
      },
      "source": [
        "**<span style=\"color:red\"> Exercise 1: </span>** : *<span style=\"color:#0b486b\"> Create a plot of  [sigmoid function](https://en.wikipedia.org/wiki/Sigmoid_function) on the interval  [−6,6]  using 256 points. Remember to label the axes! In the following code, we give you the code for sigmoid function.\n",
        "</span>*. Hint: using the *linspace* function in numpy to create array values for x axis.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x2h62wZ0JlJX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# def sigmoid(x,a,b):\n",
        "# # sigmoid function with parameters a = center; b = width\n",
        "#     return 1/(1+np.exp(-(x-a)/b))\n",
        "\n",
        "def sigmoid(x):\n",
        "    return 1/(1+np.exp(-x))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pcM36GgMJlJc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Enter you code here           \n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mwim-CxiJlJg",
        "colab_type": "text"
      },
      "source": [
        "## Pandas <!--3.3 Pandas-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eNqcfJCkJlJh",
        "colab_type": "text"
      },
      "source": [
        "Pandas provides data structures and functionality to quickly manipulate and analyze data. The\n",
        "key to understanding Pandas for machine learning is understanding the **Series** and **DataFrame**\n",
        "data structures."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CKiCG9NCJlJj",
        "colab_type": "text"
      },
      "source": [
        "### Series <!--3.3.1 Series-->\n",
        "A series is a one dimensional array of data where the rows are labeled using a time axis. You can access the data in a series like a NumPy array or like a dictionary.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lldygGg7JlJk",
        "colab_type": "code",
        "outputId": "699e109d-f6e1-47af-adc4-9e8e56e68891",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        }
      },
      "source": [
        "# series\n",
        "import numpy\n",
        "import pandas\n",
        "myarray = numpy.array([1, 2, 3])\n",
        "rownames = ['a', 'b', 'c']\n",
        "myseries = pandas.Series(myarray, index=rownames)\n",
        "print(myseries)\n",
        "\n",
        "print(myseries[0])\n",
        "print(myseries['a'])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a    1\n",
            "b    2\n",
            "c    3\n",
            "dtype: int64\n",
            "1\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g4LPp1BTJlJp",
        "colab_type": "text"
      },
      "source": [
        "### DataFrame <!--3.3.2 DataFrame-->\n",
        "A data frame is a multi-dimensional array where the rows and the columns can be labeled.A data frame can be indexed using column names."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oIXiQHuWJlJq",
        "colab_type": "code",
        "outputId": "fc8f64ad-6a75-422e-983f-13da979933f9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        }
      },
      "source": [
        "# dataframe\n",
        "import numpy\n",
        "import pandas\n",
        "myarray = numpy.array([[1, 2, 3], [4, 5, 6]])\n",
        "rownames = ['a', 'b']\n",
        "colnames = ['one', 'two', 'three']\n",
        "mydataframe = pandas.DataFrame(myarray, index=rownames, columns=colnames)\n",
        "print(mydataframe)\n",
        "\n",
        "print(\"method 1:\")\n",
        "print(\"one column:\\n%s\" % mydataframe['one'])\n",
        "\n",
        "print(\"method 2:\")\n",
        "print(\"one column:\\n%s\" % mydataframe.one)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "   one  two  three\n",
            "a    1    2      3\n",
            "b    4    5      6\n",
            "method 1:\n",
            "one column:\n",
            "a    1\n",
            "b    4\n",
            "Name: one, dtype: int64\n",
            "method 2:\n",
            "one column:\n",
            "a    1\n",
            "b    4\n",
            "Name: one, dtype: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oc-9fbRTJlJu",
        "colab_type": "text"
      },
      "source": [
        "Examples for manipulation with data using can be found at [Pandas cookbook](http://pandas.pydata.org/pandas-docs/stable/cookbook.html) which provides many short and nice examples."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N4Ub1jOHJlJv",
        "colab_type": "text"
      },
      "source": [
        "## Scipy <!--3.4 Scipy-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "irInSzUJJlJw",
        "colab_type": "text"
      },
      "source": [
        "Optimization (finding minima or maxima of a function) is a package which is usual used in machine learning. Here we will only look at a few very simple cases.\n",
        "\n",
        "To use the optimization module in scipy first include the optimize module:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "raxq0l1mJlJx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from scipy import optimize\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pOOJpK3EJlJ2",
        "colab_type": "text"
      },
      "source": [
        "Let's first look at how to find the minima of a simple function of a single variable:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TYiYo_ALJlJ3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def f(x):\n",
        "    return 4*x**3 + (x-2)**2 + x**4"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x4Dvy3dWJlJ6",
        "colab_type": "text"
      },
      "source": [
        "which can be plotted as "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lc64d_4mJlJ7",
        "colab_type": "code",
        "outputId": "6864c6af-8b50-4bc3-ee7f-a08ef05403b7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        }
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "fig, ax  = plt.subplots()\n",
        "x = np.linspace(-5, 3, 100)\n",
        "ax.plot(x, f(x))\n",
        "plt.show()\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nGAAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y6xXuUrnJlJ_",
        "colab_type": "text"
      },
      "source": [
        "We can use the *fmin_bfgs* function to find the minima of a function:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8zghESqKJlJ_",
        "colab_type": "code",
        "outputId": "24ccedc5-67f8-4ff8-f4b7-6a1e9ff2a0ef",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        }
      },
      "source": [
        "x_min = optimize.fmin_bfgs(f, -2)\n",
        "print(x_min )"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Optimization terminated successfully.\n",
            "         Current function value: -3.506641\n",
            "         Iterations: 5\n",
            "         Function evaluations: 24\n",
            "         Gradient evaluations: 8\n",
            "[-2.67298151]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FlhXYalsJlKC",
        "colab_type": "text"
      },
      "source": [
        "For a more detailed introduction to optimization with SciPy see: [Scipy Optimization](http://scipy-lectures.github.com/advanced/mathematical_optimization/index.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IZTcXyLOJlKG",
        "colab_type": "text"
      },
      "source": [
        "## Further reading <!--4.4 Further reading-->\n",
        "* More tutorials, videos on machine learning with scikit-learn can be found at [Introduction to machine learning with scikit-learn](https://github.com/justmarkham/scikit-learn-videos).\n",
        " \n",
        "\n",
        "* Short and concise introduction to Python 3 is introduced in the [cheatsheet](https://perso.limsi.fr/pointal/_media/python:cours:mementopython3-english.pdf)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iXCojwgyJlKJ",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "    \n",
        "<div class=\"alert alert-warning\">\n",
        "<b>NOTE</b> Uploading data files is only necessary when running the notebook online.\n",
        "</div>"
      ]
    }
  ]
}