Exercises/05 Exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-430d835796356075",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "## Exercise 05.1 (random numbers)\n",
    "\n",
    "- Using the `randint` function from the `random` module (https://docs.python.org/3/library/random.html#random.randint) to\n",
    "  develop a function `dice_roll` that emulates the roll of a dice with $n$ sides. The number of sides `n` should an argument to the function.\n",
    "\n",
    "- For $n=6$, devise and implement a test to check that it is a fair dice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-12092bd5f2adea76",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "#### (a) Dice roll code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-70a83466894475ee",
     "locked": false,
     "schema_version": 3,
     "solution": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-0970743b0c035f78",
     "locked": true,
     "points": 0,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "## tests ##\n",
    "for n in range(1, 20):\n",
    "    for j in range(100):\n",
    "        value = dice_roll(n) \n",
    "        assert value >= 1 and value <= n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-8fd8c957cbce8e91",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "#### (b) Test for fairness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-0826760c62c21bff",
     "locked": false,
     "points": 0,
     "schema_version": 3,
     "solution": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# To check for fairness, we roll the dice a large number of times and check how many times we get each value. \n",
    "# We expect to get each value close to $1/6$ of the times. \n",
    "\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 05.2 (variance estimation)\n",
    "\n",
    "For a random variable $X$, the variance of $X$ is defined as  \n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "\\mathrm{Var}\\left[ X \\right] &= \\mathrm{E}\\left[\\left( X - \\mu \\right)^2\\right]  \\\\ \n",
    "&= \\mathrm{E}\\left[ X^{2} \\right] - \\mathrm{E}\\left[ X \\right]^2\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "where $\\mathrm{E}$ is the 'expectation' (mean of something) and $\\mu = \\mathrm{E}(X)$ is the mean of $X$. If we have all data (the entire 'population'),\n",
    "the variance can be computed from:\n",
    "\n",
    "$$\n",
    "\\mathrm{Var}\\left[ X \\right] = \\frac{\\sum_{i=0}^{N-1} x^{2}_{i}}{N} - \\left( \\frac{ \\left( \\sum_{i=0}^{N-1} x_{i} \\right)}{N} \\right)^{2}\n",
    "$$\n",
    "\n",
    "Often, we only have a sample of data. For example, we might want to estimate the variance in height for students at a university using just a random sample of students. \n",
    "When using a sample from a larger data set to estimate the variance, the above formula has a *bias*. Therefore, it is common to use the *unbiased* estimator\n",
    "\n",
    "$$\n",
    "s^{2} = \\left( \\frac{\\sum_{i=0}^{n-1} x^{2}_{i}}{n} - \\left( \\frac{ \\left( \\sum_{i=0}^{n-1} x_{i} \\right)}{n} \\right)^{2} \\right) \\frac{n}{n-1}\n",
    "$$\n",
    "\n",
    "to estimate the variance. In this exercise we will use the unbiased estimator.\n",
    "\n",
    "1. Create a function that returns the estimated variance for a list of numbers based on the above equation. Test your function using 1 million samples drawn from a Gaussian distribution with a mean of 10 and a standard deviation of 3. Use your crsid to seed the random number generator\n",
    "   \n",
    "   *See hint below on how to create the sample.*\n",
    "\n",
    "2. For a sample drawn from a distribution with mean $5 \\times 10^6$ and standard deviation $2.0$, estimate the variance using (i) your function for estimating the variance, and (ii) using the `variance` function from the Python `statistics` module. Comment on and explain any significant differences in the results from (i) and (ii)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hint: sampling from a distribution\n",
    "\n",
    "The function `random.gauss` can be used to sample a Gaussian distribution with a specified mean and standard deviation (square root of the variance) *N* times, e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "random.seed(\"gnw20\")  # See the random number generator\n",
    "\n",
    "mu = 10.0    # mean of the distribution\n",
    "sigma = 3.0  # Standard deviation\n",
    "x = [random.gauss(mu, sigma) for i in range(8)]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Estimate variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import random\n",
    "random.seed(\"gnw20\")\n",
    "\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Use the `statistics` module to estimate the variance, and compare the estimated variance using `statistics` to the estimated variance using your implementation for the variance estimation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 05.03 (optional, parallel processing)\n",
    "\n",
    "Almost all modern computer processing units have multiple processing *cores*. To utilise the full performance of a processor, operations need to be performed in *parallel*, i.e. each processing core is given a task to perform.\n",
    "\n",
    "Parallel computing is a very rich and technical area. To help exploit multi-core systems there are libraries that support parallel processing. Below is a simple example using the Python `multiprocessing` library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import multiprocessing\n",
    "\n",
    "# On some operaring systems, you may need to uncomment the below line\n",
    "# multiprocessing.set_start_method('fork')\n",
    "\n",
    "def f(task):\n",
    "    \"\"\"A function that print the input argument and the id for the process that executes the function\"\"\"\n",
    "    print(f\"Task index {task}, process id: {multiprocessing.current_process()}\\n\")\n",
    "     \n",
    "    return str(multiprocessing.current_process())\n",
    "        \n",
    "        \n",
    "# Using 3 'processes', execute the function 'f' four times (each time with a different argument)  \n",
    "with multiprocessing.Pool(processes=3) as p:\n",
    "    procs = p.map(f, [0, 1, 2, 3])  # Call function mysort three times\n",
    "    \n",
    "    print(\"Returned data (a list)\") \n",
    "    print(procs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the below code that creates a list of lists of sorted numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mysort(N):\n",
    "    \"\"\"Create a randomly ordered list of integers of length N, and return the sorted list\"\"\"\n",
    "    # Create randomly ordered list\n",
    "    x = random.sample(range(0, N), N)\n",
    " \n",
    "    # Return sorted list of numbers\n",
    "    return sorted(x)\n",
    "\n",
    "def sorted_lists(N, p):\n",
    "    \"\"\"Create a list of sorted lists\"\"\"\n",
    "    data = []\n",
    "    for i in range(p):\n",
    "        data.append(mysort(N))\n",
    "\n",
    "%time x = sorted_lists(1000000, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the `multiprocessing` module to perform the above operation in parallel. Investigate how the processing time changes with the number of processes, and in particular the average time per 'create and sort operation' when changing the number of processes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "..."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Create Assignment",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  },
  "otter": {
   "OK_FORMAT": true,
   "assignment_name": "Exercises 5",
   "tests": {}
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}