1. Random Numbers in NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random Numbers in NumPy\n",
    "**By Hans Perez Rubin de Celis**\n",
    "\n",
    "## What is a Random Number?\n",
    "\n",
    "In this notebook I will answer and discuss following points:\n",
    "\n",
    "### 1. Explain the overall purpose of the package.\n",
    "\n",
    "It is a Python package, specialized for building and manipulating large and multidimensional arrays. NumPy has built-in functions for linear algebra and random number generation. It is an important library because many of the other Python packages like SciPy, Matplotlib depend on Numpy to work (to a reasonable extent).\n",
    "\n",
    "The numpy.random module supplements Python's built-in random with functions to efficiently generate complete arrays of sample values ​​from many types of probability distributions. Python Source for Data Analysis by Wes McKinney\n",
    "\n",
    "Numpy has some benefits over Python lists, such as: being more compact, faster access to reading and writing items, being more convenient, and more efficient.\n",
    "\n",
    "The Numpy matrix is ​​a powerful N-dimensional matrix object that is in the form of rows and columns.\n",
    "\n",
    "\n",
    "Numpy array is a powerful N-dimensional array object which is in the form of rows and columns.\n",
    "\n",
    "> NumPy is one of the most fundamental Python packages that we use for machine learning research and other scientific computing jobs. As a wrapper around a C-implemented library, NumPy provides a wide collection of powerful algebraic and transformation operations on its multi-dimensional array and matrix data structures.\n",
    "Besides these mathematical operations, it provides various functionalities to generate random numbers that serve different purposes in scientific computing in general. This article reviews the common functions that we can use to generate random numbers in NumPy.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import libraries\n",
    "\n",
    "import numpy as np \n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from matplotlib.ticker import FuncFormatter\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To begin with, we’ll first import the NumPy module by running `import numpy as np`, allowing us to access all relevant functions in the module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. rand(d0, d1, ..., dn)\n",
    "\n",
    "This method generates random numbers in a given shape. Some common examples are given below. Note that the numbers specified in the `rand()` function correspond to the number of dimensions of the array that is to be generated. A special case is that when no numbers are specified in the function, a random value will be generated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5242129213883749"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.40819305, 0.25478462, 0.21127347, 0.83931419])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.27452013, 0.4426765 , 0.23433773, 0.86329531],\n",
       "       [0.02179784, 0.23914946, 0.24846379, 0.41607698],\n",
       "       [0.3212738 , 0.37238859, 0.43868957, 0.30780613]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand(3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. randn(d0, d1, …, dn) and standard_normal([size])\n",
    "\n",
    "Both methods are used to generate random numbers from the standard **normal distribution**, the curves of which are shown in the figure below. The red curve shows you the standard normal distribution with a mean of 0 and standard deviation of 1.\n",
    "\n",
    "![Imagent](https://miro.medium.com/max/640/1*PfODI74UmIlRfDj0q-I3Kw.png)\n",
    "\n",
    "               Standard Normal Distribution Shown By Read Curve (Source: Wikipedia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both methods are to draw numbers randomly from the distribution to generate arrays of the defined shape. Their usages are about the same, except that for the `standard_normal()` method, we need to use a tuple to set the shape size. Some common examples are given below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.3313793 , -0.6290491 , -1.32802086,  1.12600619])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randn(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.21958963,  1.37344998, -0.76465731, -0.34423846])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.standard_normal(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2.20192462,  0.33804294, -0.12459822,  0.6253378 ],\n",
       "       [-0.68935147,  0.19298454,  0.13677727, -1.28035122],\n",
       "       [ 0.25459891,  0.07304403,  1.12014755,  0.01194971]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randn(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.78282052,  0.44044007, -0.31580395, -0.91511864],\n",
       "       [-0.3057786 ,  0.11654818, -0.61014077,  0.84368814],\n",
       "       [-0.01610043, -0.1624691 ,  0.79220272, -0.92421283]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.standard_normal((3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Random Numbers With randn() and standard_normal()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One thing to note is that because we know that these methods are to create a sample of numbers from the standard normal distribution, and thus we can verify if this is the case shown in the figure below.\n",
    "\n",
    "![Imagent](https://miro.medium.com/max/700/1*lf2i_mThsohI2KJKIb0H_Q.png)\n",
    "\n",
    "            Histogram of Random Numbers Generated With randn()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Related to these two methods, there is another method called `normal([loc, scale, size])`, using which we can generate random numbers from the normal distribution specified by loc and scale parameters.\n",
    "\n",
    "## 3. randint (low[, high, size, dtype])\n",
    "\n",
    "This method generates random integers in the shape defined by size from `low` (inclusive) to `high` (exclusive) in the discrete uniform distribution. Optionally, we can also set the `dtype` as `int64`, `int`, or something else, with `np.int` being the default value.\n",
    "\n",
    "One thing to note is that when we don’t set the `high` argument, the numbers will be generated in the range of [0, `low`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "77"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([58, 78,  6, 10])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(1,100,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[51, 11, 26, 49],\n",
       "       [34, 59, 61, 17],\n",
       "       [81,  5, 96, 14],\n",
       "       [78, 45, 26, 70]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(1,100,(4,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "            Random Numbers With randint()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. `random_sample`([size]), `random`([size]), `ranf`([size]), and `sample`([size])\n",
    "\n",
    "All of these functions are to generate random floats in the shape defined by size in the range of [0.0, 1,0)which is a continuous uniform distribution. Using `random_sample()` as an example, the relevant use cases are shown below.\n",
    "\n",
    "One thing to note that as these random numbers are drawn from the continuous uniform distribution of [0.0, 1.0), and thus the mean of these numbers is around 0.5, which is the half of the sum of 0.0 and 1.0.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.47168791, 0.56669097, 0.25723845, 0.28733977])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.random_sample(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.18135451, 0.95880993, 0.53980955, 0.65652418],\n",
       "       [0.81330711, 0.76647847, 0.02664784, 0.55285811],\n",
       "       [0.93813651, 0.55089549, 0.85228934, 0.82232812],\n",
       "       [0.91485009, 0.84230159, 0.54038327, 0.58764068]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.random_sample((4,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.49907105245724126\n"
     ]
    }
   ],
   "source": [
    "s=np.random.random_sample(100000)\n",
    "print(np.mean(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                    Random Numbers With random_sample()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Related to these four methods, there is another method called `uniform([low, high, size])`, using which we can generate random numbers from the half-open uniform distribution specified by `low` and `high` parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. `choice`(a[, size, replace, p])\n",
    "\n",
    "This method generates a random sample from a given 1-D array specified by the argument `a`. However, if a is set as an int, the method will run as if `a` were an `ndarray` generated from `np.arange(a)`. Some examples using this method are shown below.\n",
    "\n",
    "The `size` argument specifies the shape of the `ndarray` that is returned, while the `p` argument is a list of floats indicating the probability of the elements in `a` for being drawn. It should be noted that if you set the `p` argument, the sum of the probability values has to be 1.0.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([41, 32, 69, 56, 60])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.choice(100,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  4,  4,  1],\n",
       "       [ 3,  1,  4,  9],\n",
       "       [10, 10, 10,  3],\n",
       "       [ 9, 10,  2, 10]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.choice([1,2,3,4,8,9,10], size =(4, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7, 3, 3],\n",
       "       [1, 1, 1],\n",
       "       [7, 7, 3]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.choice([1,3,5,7],size=(3,3), p=[0.2,0.2,0,0.6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. `shuffle`(x) and `permutation`(x)\n",
    "\n",
    "Both methods are used to permute the sequence randomly. The major difference between them is that the `shuffle()` method modifies the sequence in-place and returns `None`, while the permutation() method generates a new `ndarray` of the same shape after the modification. Let’s see some examples below.\n",
    "\n",
    "One thing to note is that when we permute a multi-dimensional array, it only works on its first axis as shown in the last two examples. In other words, the contents of the subarrays in a multi-dimensional array stay the same.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7,  8,  1, 43])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([7,8,1,43]) \n",
    "a\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([43,  1,  7,  8])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.shuffle(a)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.52152834, 0.16293589, 0.47092595, 0.65910337],\n",
       "       [0.26990571, 0.19192449, 0.5164152 , 0.4195702 ],\n",
       "       [0.16938409, 0.46676504, 0.29644378, 0.63727644],\n",
       "       [0.8041953 , 0.16136357, 0.6076296 , 0.17502824]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.random.random((4,4))\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.26990571, 0.19192449, 0.5164152 , 0.4195702 ],\n",
       "       [0.52152834, 0.16293589, 0.47092595, 0.65910337],\n",
       "       [0.16938409, 0.46676504, 0.29644378, 0.63727644],\n",
       "       [0.8041953 , 0.16136357, 0.6076296 , 0.17502824]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.permutation(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusions\n",
    "\n",
    "This article reviews the commonly used methods of generating random numbers in NumPy, one of the most powerful packages for performing matrix and matrix calculations. There is more to explore on their official website. https://docs.scipy.org/doc/numpy-1.14.0/reference/routines.random.html\n",
    "\n",
    "Here’s a quick cheat sheet about these methods for your quick reference.\n",
    "\n",
    "https://gist.github.com/ycui1/726ddea5fdaa8a8e664f4072198935fb#file-numpy_random-csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}