{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Sampling"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Synopsis"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Effect on proportion\n",
" - Percentages\n",
" - Bad as percentage can have different intuition for different ranges \n",
" - Difference is subjective\n",
" - Odds Ratio\n",
" - LOR\n",
" - Most appropriate (symmetric)\n",
"\n",
"- Choosing Effect Size indicator is driven by context and familiarity. Use something which makes sense to individuals/ audience\n",
"\n",
"- Precision\n",
" - How precise is data?\n",
" - Sources of Errors\n",
" - Sampling Errors\n",
" - Is my sample representative of population?\n",
" - Measurement Errors\n",
" - UOM\n",
" - Improper Recording \n",
" - Random Errors\n",
" - Least important \n",
" - Only one with mathematical model behind it, so it's used all the time in statistics classes\n",
" \n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Imports"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import scipy as sp\n",
"import scipy.stats as stats\n",
"import matplotlib as mpl\n",
"import matplotlib.pyplot as plt\n",
"from ipywidgets import interact, interactive, fixed\n",
"import ipywidgets as widgets\n",
"import pandas as pd\n",
"from IPython.display import display, display_html\n",
"import bqplot\n",
"\n",
"from bqplot import LinearScale, Hist, Figure, Axis, ColorScale\n",
"\n",
"from bqplot import pyplot as pltbq\n",
"# import seaborn as sns\n",
"# seed the random number generator so we all get the same results\n",
"np.random.seed(17)\n",
"\n",
"# some nice colors from http://colorbrewer2.org/\n",
"COLOR1 = '#7fc97f'\n",
"COLOR2 = '#beaed4'\n",
"COLOR3 = '#fdc086'\n",
"COLOR4 = '#ffff99'\n",
"COLOR5 = '#386cb0'\n",
"\n",
"mpl.rcParams['figure.figsize'] = (8.0, 9.0)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib inline"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Part 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Estimate Avg. weight of man & woman in US\n",
"- Quantify uncertainity in estimate\n",
"- Approach => \n",
" - Simulate many exp\n",
" - Compare how results vary from one experiment to another\n",
" \n",
"- Start by assuming distribution and move on show how to eliminate this assumption (solve without it)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(72.69764573296688, 16.944043048498038)"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Weight of woman(in kg)\n",
"\n",
"weight = stats.lognorm(0.23, 0, 70.8)\n",
"weight.mean(), weight.std()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Help on lognorm_gen in module scipy.stats._continuous_distns object:\n",
"\n",
"class lognorm_gen(scipy.stats._distn_infrastructure.rv_continuous)\n",
" | lognorm_gen(momtype=1, a=None, b=None, xtol=1e-14, badvalue=None, name=None, longname=None, shapes=None, extradoc=None, seed=None)\n",
" | \n",
" | A lognormal continuous random variable.\n",
" | \n",
" | %(before_notes)s\n",
" | \n",
" | Notes\n",
" | -----\n",
" | The probability density function for `lognorm` is:\n",
" | \n",
" | .. math::\n",
" | \n",
" | f(x, s) = \\frac{1}{s x \\sqrt{2\\pi}}\n",
" | \\exp\\left(-\\frac{\\log^2(x)}{2s^2}\\right)\n",
" | \n",
" | for :math:`x > 0`, :math:`s > 0`.\n",
" | \n",
" | `lognorm` takes ``s`` as a shape parameter for :math:`s`.\n",
" | \n",
" | %(after_notes)s\n",
" | \n",
" | A common parametrization for a lognormal random variable ``Y`` is in\n",
" | terms of the mean, ``mu``, and standard deviation, ``sigma``, of the\n",
" | unique normally distributed random variable ``X`` such that exp(X) = Y.\n",
" | This parametrization corresponds to setting ``s = sigma`` and ``scale =\n",
" | exp(mu)``.\n",
" | \n",
" | %(example)s\n",
" | \n",
" | Method resolution order:\n",
" | lognorm_gen\n",
" | scipy.stats._distn_infrastructure.rv_continuous\n",
" | scipy.stats._distn_infrastructure.rv_generic\n",
" | builtins.object\n",
" | \n",
" | Methods defined here:\n",
" | \n",
" | fit(self, data, *args, **kwds)\n",
" | Return MLEs for shape (if applicable), location, and scale\n",
" | parameters from data.\n",
" | \n",
" | MLE stands for Maximum Likelihood Estimate. Starting estimates for\n",
" | the fit are given by input arguments; for any arguments not provided\n",
" | with starting estimates, ``self._fitstart(data)`` is called to generate\n",
" | such.\n",
" | \n",
" | One can hold some parameters fixed to specific values by passing in\n",
" | keyword arguments ``f0``, ``f1``, ..., ``fn`` (for shape parameters)\n",
" | and ``floc`` and ``fscale`` (for location and scale parameters,\n",
" | respectively).\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | data : array_like\n",
" | Data to use in calculating the MLEs.\n",
" | arg1, arg2, arg3,... : floats, optional\n",
" | Starting value(s) for any shape-characterizing arguments (those not\n",
" | provided will be determined by a call to ``_fitstart(data)``).\n",
" | No default value.\n",
" | kwds : floats, optional\n",
" | - `loc`: initial guess of the distribution's location parameter.\n",
" | - `scale`: initial guess of the distribution's scale parameter.\n",
" | \n",
" | Special keyword arguments are recognized as holding certain\n",
" | parameters fixed:\n",
" | \n",
" | - f0...fn : hold respective shape parameters fixed.\n",
" | Alternatively, shape parameters to fix can be specified by name.\n",
" | For example, if ``self.shapes == \"a, b\"``, ``fa`` and ``fix_a``\n",
" | are equivalent to ``f0``, and ``fb`` and ``fix_b`` are\n",
" | equivalent to ``f1``.\n",
" | \n",
" | - floc : hold location parameter fixed to specified value.\n",
" | \n",
" | - fscale : hold scale parameter fixed to specified value.\n",
" | \n",
" | - optimizer : The optimizer to use. The optimizer must take ``func``,\n",
" | and starting position as the first two arguments,\n",
" | plus ``args`` (for extra arguments to pass to the\n",
" | function to be optimized) and ``disp=0`` to suppress\n",
" | output as keyword arguments.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | mle_tuple : tuple of floats\n",
" | MLEs for any shape parameters (if applicable), followed by those\n",
" | for location and scale. For most random variables, shape statistics\n",
" | will be returned, but there are exceptions (e.g. ``norm``).\n",
" | \n",
" | Notes\n",
" | -----\n",
" | This fit is computed by maximizing a log-likelihood function, with\n",
" | penalty applied for samples outside of range of the distribution. The\n",
" | returned answer is not guaranteed to be the globally optimal MLE, it\n",
" | may only be locally optimal, or the optimization may fail altogether.\n",
" | If the data contain any of np.nan, np.inf, or -np.inf, the fit routine\n",
" | will throw a RuntimeError.\n",
" | \n",
" | When the location parameter is fixed by using the `floc` argument,\n",
" | this function uses explicit formulas for the maximum likelihood\n",
" | estimation of the log-normal shape and scale parameters, so the\n",
" | `optimizer`, `loc` and `scale` keyword arguments are ignored.\n",
" | \n",
" | Examples\n",
" | --------\n",
" | \n",
" | Generate some data to fit: draw random variates from the `beta`\n",
" | distribution\n",
" | \n",
" | >>> from scipy.stats import beta\n",
" | >>> a, b = 1., 2.\n",
" | >>> x = beta.rvs(a, b, size=1000)\n",
" | \n",
" | Now we can fit all four parameters (``a``, ``b``, ``loc`` and ``scale``):\n",
" | \n",
" | >>> a1, b1, loc1, scale1 = beta.fit(x)\n",
" | \n",
" | We can also use some prior knowledge about the dataset: let's keep\n",
" | ``loc`` and ``scale`` fixed:\n",
" | \n",
" | >>> a1, b1, loc1, scale1 = beta.fit(x, floc=0, fscale=1)\n",
" | >>> loc1, scale1\n",
" | (0, 1)\n",
" | \n",
" | We can also keep shape parameters fixed by using ``f``-keywords. To\n",
" | keep the zero-th shape parameter ``a`` equal 1, use ``f0=1`` or,\n",
" | equivalently, ``fa=1``:\n",
" | \n",
" | >>> a1, b1, loc1, scale1 = beta.fit(x, fa=1, floc=0, fscale=1)\n",
" | >>> a1\n",
" | 1\n",
" | \n",
" | Not all distributions return estimates for the shape parameters.\n",
" | ``norm`` for example just returns estimates for location and scale:\n",
" | \n",
" | >>> from scipy.stats import norm\n",
" | >>> x = norm.rvs(a, b, size=1000, random_state=123)\n",
" | >>> loc1, scale1 = norm.fit(x)\n",
" | >>> loc1, scale1\n",
" | (0.92087172783841631, 2.0015750750324668)\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from scipy.stats._distn_infrastructure.rv_continuous:\n",
" | \n",
" | __init__(self, momtype=1, a=None, b=None, xtol=1e-14, badvalue=None, name=None, longname=None, shapes=None, extradoc=None, seed=None)\n",
" | Initialize self. See help(type(self)) for accurate signature.\n",
" | \n",
" | cdf(self, x, *args, **kwds)\n",
" | Cumulative distribution function of the given RV.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | x : array_like\n",
" | quantiles\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information)\n",
" | loc : array_like, optional\n",
" | location parameter (default=0)\n",
" | scale : array_like, optional\n",
" | scale parameter (default=1)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | cdf : ndarray\n",
" | Cumulative distribution function evaluated at `x`\n",
" | \n",
" | expect(self, func=None, args=(), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds)\n",
" | Calculate expected value of a function with respect to the\n",
" | distribution by numerical integration.\n",
" | \n",
" | The expected value of a function ``f(x)`` with respect to a\n",
" | distribution ``dist`` is defined as::\n",
" | \n",
" | ub\n",
" | E[f(x)] = Integral(f(x) * dist.pdf(x)),\n",
" | lb\n",
" | \n",
" | where ``ub`` and ``lb`` are arguments and ``x`` has the ``dist.pdf(x)``\n",
" | distribution. If the bounds ``lb`` and ``ub`` correspond to the\n",
" | support of the distribution, e.g. ``[-inf, inf]`` in the default\n",
" | case, then the integral is the unrestricted expectation of ``f(x)``.\n",
" | Also, the function ``f(x)`` may be defined such that ``f(x)`` is ``0``\n",
" | outside a finite interval in which case the expectation is\n",
" | calculated within the finite range ``[lb, ub]``.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | func : callable, optional\n",
" | Function for which integral is calculated. Takes only one argument.\n",
" | The default is the identity mapping f(x) = x.\n",
" | args : tuple, optional\n",
" | Shape parameters of the distribution.\n",
" | loc : float, optional\n",
" | Location parameter (default=0).\n",
" | scale : float, optional\n",
" | Scale parameter (default=1).\n",
" | lb, ub : scalar, optional\n",
" | Lower and upper bound for integration. Default is set to the\n",
" | support of the distribution.\n",
" | conditional : bool, optional\n",
" | If True, the integral is corrected by the conditional probability\n",
" | of the integration interval. The return value is the expectation\n",
" | of the function, conditional on being in the given interval.\n",
" | Default is False.\n",
" | \n",
" | Additional keyword arguments are passed to the integration routine.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | expect : float\n",
" | The calculated expected value.\n",
" | \n",
" | Notes\n",
" | -----\n",
" | The integration behavior of this function is inherited from\n",
" | `scipy.integrate.quad`. Neither this function nor\n",
" | `scipy.integrate.quad` can verify whether the integral exists or is\n",
" | finite. For example ``cauchy(0).mean()`` returns ``np.nan`` and\n",
" | ``cauchy(0).expect()`` returns ``0.0``.\n",
" | \n",
" | The function is not vectorized.\n",
" | \n",
" | Examples\n",
" | --------\n",
" | \n",
" | To understand the effect of the bounds of integration consider\n",
" | \n",
" | >>> from scipy.stats import expon\n",
" | >>> expon(1).expect(lambda x: 1, lb=0.0, ub=2.0)\n",
" | 0.6321205588285578\n",
" | \n",
" | This is close to\n",
" | \n",
" | >>> expon(1).cdf(2.0) - expon(1).cdf(0.0)\n",
" | 0.6321205588285577\n",
" | \n",
" | If ``conditional=True``\n",
" | \n",
" | >>> expon(1).expect(lambda x: 1, lb=0.0, ub=2.0, conditional=True)\n",
" | 1.0000000000000002\n",
" | \n",
" | The slight deviation from 1 is due to numerical integration.\n",
" | \n",
" | fit_loc_scale(self, data, *args)\n",
" | Estimate loc and scale parameters from data using 1st and 2nd moments.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | data : array_like\n",
" | Data to fit.\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information).\n",
" | \n",
" | Returns\n",
" | -------\n",
" | Lhat : float\n",
" | Estimated location parameter for the data.\n",
" | Shat : float\n",
" | Estimated scale parameter for the data.\n",
" | \n",
" | isf(self, q, *args, **kwds)\n",
" | Inverse survival function (inverse of `sf`) at q of the given RV.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | q : array_like\n",
" | upper tail probability\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information)\n",
" | loc : array_like, optional\n",
" | location parameter (default=0)\n",
" | scale : array_like, optional\n",
" | scale parameter (default=1)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | x : ndarray or scalar\n",
" | Quantile corresponding to the upper tail probability q.\n",
" | \n",
" | logcdf(self, x, *args, **kwds)\n",
" | Log of the cumulative distribution function at x of the given RV.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | x : array_like\n",
" | quantiles\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information)\n",
" | loc : array_like, optional\n",
" | location parameter (default=0)\n",
" | scale : array_like, optional\n",
" | scale parameter (default=1)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | logcdf : array_like\n",
" | Log of the cumulative distribution function evaluated at x\n",
" | \n",
" | logpdf(self, x, *args, **kwds)\n",
" | Log of the probability density function at x of the given RV.\n",
" | \n",
" | This uses a more numerically accurate calculation if available.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | x : array_like\n",
" | quantiles\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information)\n",
" | loc : array_like, optional\n",
" | location parameter (default=0)\n",
" | scale : array_like, optional\n",
" | scale parameter (default=1)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | logpdf : array_like\n",
" | Log of the probability density function evaluated at x\n",
" | \n",
" | logsf(self, x, *args, **kwds)\n",
" | Log of the survival function of the given RV.\n",
" | \n",
" | Returns the log of the \"survival function,\" defined as (1 - `cdf`),\n",
" | evaluated at `x`.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | x : array_like\n",
" | quantiles\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information)\n",
" | loc : array_like, optional\n",
" | location parameter (default=0)\n",
" | scale : array_like, optional\n",
" | scale parameter (default=1)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | logsf : ndarray\n",
" | Log of the survival function evaluated at `x`.\n",
" | \n",
" | nnlf(self, theta, x)\n",
" | Return negative loglikelihood function.\n",
" | \n",
" | Notes\n",
" | -----\n",
" | This is ``-sum(log pdf(x, theta), axis=0)`` where `theta` are the\n",
" | parameters (including loc and scale).\n",
" | \n",
" | pdf(self, x, *args, **kwds)\n",
" | Probability density function at x of the given RV.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | x : array_like\n",
" | quantiles\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information)\n",
" | loc : array_like, optional\n",
" | location parameter (default=0)\n",
" | scale : array_like, optional\n",
" | scale parameter (default=1)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | pdf : ndarray\n",
" | Probability density function evaluated at x\n",
" | \n",
" | ppf(self, q, *args, **kwds)\n",
" | Percent point function (inverse of `cdf`) at q of the given RV.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | q : array_like\n",
" | lower tail probability\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information)\n",
" | loc : array_like, optional\n",
" | location parameter (default=0)\n",
" | scale : array_like, optional\n",
" | scale parameter (default=1)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | x : array_like\n",
" | quantile corresponding to the lower tail probability q.\n",
" | \n",
" | sf(self, x, *args, **kwds)\n",
" | Survival function (1 - `cdf`) at x of the given RV.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | x : array_like\n",
" | quantiles\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information)\n",
" | loc : array_like, optional\n",
" | location parameter (default=0)\n",
" | scale : array_like, optional\n",
" | scale parameter (default=1)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | sf : array_like\n",
" | Survival function evaluated at x\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from scipy.stats._distn_infrastructure.rv_generic:\n",
" | \n",
" | __call__(self, *args, **kwds)\n",
" | Freeze the distribution for the given arguments.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution. Should include all\n",
" | the non-optional arguments, may include ``loc`` and ``scale``.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | rv_frozen : rv_frozen instance\n",
" | The frozen distribution.\n",
" | \n",
" | __getstate__(self)\n",
" | \n",
" | __setstate__(self, state)\n",
" | \n",
" | entropy(self, *args, **kwds)\n",
" | Differential entropy of the RV.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information).\n",
" | loc : array_like, optional\n",
" | Location parameter (default=0).\n",
" | scale : array_like, optional (continuous distributions only).\n",
" | Scale parameter (default=1).\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Entropy is defined base `e`:\n",
" | \n",
" | >>> drv = rv_discrete(values=((0, 1), (0.5, 0.5)))\n",
" | >>> np.allclose(drv.entropy(), np.log(2.0))\n",
" | True\n",
" | \n",
" | freeze(self, *args, **kwds)\n",
" | Freeze the distribution for the given arguments.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution. Should include all\n",
" | the non-optional arguments, may include ``loc`` and ``scale``.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | rv_frozen : rv_frozen instance\n",
" | The frozen distribution.\n",
" | \n",
" | interval(self, alpha, *args, **kwds)\n",
" | Confidence interval with equal areas around the median.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | alpha : array_like of float\n",
" | Probability that an rv will be drawn from the returned range.\n",
" | Each value should be in the range [0, 1].\n",
" | arg1, arg2, ... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information).\n",
" | loc : array_like, optional\n",
" | location parameter, Default is 0.\n",
" | scale : array_like, optional\n",
" | scale parameter, Default is 1.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | a, b : ndarray of float\n",
" | end-points of range that contain ``100 * alpha %`` of the rv's\n",
" | possible values.\n",
" | \n",
" | mean(self, *args, **kwds)\n",
" | Mean of the distribution.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information)\n",
" | loc : array_like, optional\n",
" | location parameter (default=0)\n",
" | scale : array_like, optional\n",
" | scale parameter (default=1)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | mean : float\n",
" | the mean of the distribution\n",
" | \n",
" | median(self, *args, **kwds)\n",
" | Median of the distribution.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information)\n",
" | loc : array_like, optional\n",
" | Location parameter, Default is 0.\n",
" | scale : array_like, optional\n",
" | Scale parameter, Default is 1.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | median : float\n",
" | The median of the distribution.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | rv_discrete.ppf\n",
" | Inverse of the CDF\n",
" | \n",
" | moment(self, n, *args, **kwds)\n",
" | n-th order non-central moment of distribution.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | n : int, n >= 1\n",
" | Order of moment.\n",
" | arg1, arg2, arg3,... : float\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information).\n",
" | loc : array_like, optional\n",
" | location parameter (default=0)\n",
" | scale : array_like, optional\n",
" | scale parameter (default=1)\n",
" | \n",
" | rvs(self, *args, **kwds)\n",
" | Random variates of given type.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information).\n",
" | loc : array_like, optional\n",
" | Location parameter (default=0).\n",
" | scale : array_like, optional\n",
" | Scale parameter (default=1).\n",
" | size : int or tuple of ints, optional\n",
" | Defining number of random variates (default is 1).\n",
" | random_state : {None, int, `~np.random.RandomState`, `~np.random.Generator`}, optional\n",
" | If `seed` is `None` the `~np.random.RandomState` singleton is used.\n",
" | If `seed` is an int, a new ``RandomState`` instance is used, seeded\n",
" | with seed.\n",
" | If `seed` is already a ``RandomState`` or ``Generator`` instance,\n",
" | then that object is used.\n",
" | Default is None.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | rvs : ndarray or scalar\n",
" | Random variates of given `size`.\n",
" | \n",
" | stats(self, *args, **kwds)\n",
" | Some statistics of the given RV.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information)\n",
" | loc : array_like, optional\n",
" | location parameter (default=0)\n",
" | scale : array_like, optional (continuous RVs only)\n",
" | scale parameter (default=1)\n",
" | moments : str, optional\n",
" | composed of letters ['mvsk'] defining which moments to compute:\n",
" | 'm' = mean,\n",
" | 'v' = variance,\n",
" | 's' = (Fisher's) skew,\n",
" | 'k' = (Fisher's) kurtosis.\n",
" | (default is 'mv')\n",
" | \n",
" | Returns\n",
" | -------\n",
" | stats : sequence\n",
" | of requested moments.\n",
" | \n",
" | std(self, *args, **kwds)\n",
" | Standard deviation of the distribution.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information)\n",
" | loc : array_like, optional\n",
" | location parameter (default=0)\n",
" | scale : array_like, optional\n",
" | scale parameter (default=1)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | std : float\n",
" | standard deviation of the distribution\n",
" | \n",
" | support(self, *args, **kwargs)\n",
" | Return the support of the distribution.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | arg1, arg2, ... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information).\n",
" | loc : array_like, optional\n",
" | location parameter, Default is 0.\n",
" | scale : array_like, optional\n",
" | scale parameter, Default is 1.\n",
" | Returns\n",
" | -------\n",
" | a, b : float\n",
" | end-points of the distribution's support.\n",
" | \n",
" | var(self, *args, **kwds)\n",
" | Variance of the distribution.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | arg1, arg2, arg3,... : array_like\n",
" | The shape parameter(s) for the distribution (see docstring of the\n",
" | instance object for more information)\n",
" | loc : array_like, optional\n",
" | location parameter (default=0)\n",
" | scale : array_like, optional\n",
" | scale parameter (default=1)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | var : float\n",
" | the variance of the distribution\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from scipy.stats._distn_infrastructure.rv_generic:\n",
" | \n",
" | __dict__\n",
" | dictionary for instance variables (if defined)\n",
" | \n",
" | __weakref__\n",
" | list of weak references to the object (if defined)\n",
" | \n",
" | random_state\n",
" | Get or set the RandomState object for generating random variates.\n",
" | \n",
" | This can be either None, int, a RandomState instance, or a\n",
" | np.random.Generator instance.\n",
" | \n",
" | If None (or np.random), use the RandomState singleton used by np.random.\n",
" | If already a RandomState or Generator instance, use it.\n",
" | If an int, use a new RandomState instance seeded with seed.\n",
"\n"
]
}
],
"source": [
"help(stats.lognorm)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```{note}\n",
"\n",
"Log normal distribution is specified by 3 parameters \n",
"\n",
"- $\\sigma$ - Shape parameter or Standard deviation of Distribution\n",
"- $m$ - Scale parameter (median) shrinking or stretching the graphs\n",
"- $\\theta$ or ($\\mu$) - Location parameter ; specifying where it is located in map\n",
"\n",
"For log normal distribution. Check following links\n",
"- [Lognormal Distribution](https://www.itl.nist.gov/div898/handbook/eda/section3/eda3669.htm#:~:text=where%20%CF%83%20is%20the%20shape,f(x)%20%3D%200.)\n",
"\n",
"- [Statisticshowto](https://www.statisticshowto.com/lognormal-distribution/)\n",
"\n",
"```\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(array([9.308e+03, 5.550e+02, 8.500e+01, 3.000e+01, 1.000e+01, 3.000e+00,\n",
" 4.000e+00, 3.000e+00, 0.000e+00, 2.000e+00]),\n",
" array([1.12258114e+00, 2.17935158e+02, 4.34747735e+02, 6.51560312e+02,\n",
" 8.68372890e+02, 1.08518547e+03, 1.30199804e+03, 1.51881062e+03,\n",
" 1.73562320e+03, 1.95243578e+03, 2.16924835e+03]),\n",
" <BarContainer object of 10 artists>)"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"rv = stats.lognorm(1, 0, 50) # Don't know shape , location , median\n",
"# xs = np.linspace(1, 100, 100)\n",
"ys = rv.rvs(10000)\n",
"plt.hist(ys)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(72.69764573296688, 16.944043048498038)"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# For women weight\n",
"weight = stats.lognorm(0.23, 0, 70.8)\n",
"weight.mean(), weight.std()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"xs = np.linspace(20, 160, 100)\n",
"ys = weight.pdf(xs)\n",
"\n",
"plt.plot(xs, ys, linewidth=4, color=COLOR1)\n",
"plt.xlabel('weight (kg)')\n",
"plt.ylabel('PDF')\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def make_sample(n=100):\n",
" sample = weight.rvs(n)\n",
" return sample"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(73.04819598338332, 16.22111742103728)"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sample = make_sample(100)\n",
"sample.mean(), sample.std()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def sample_stat(sample):\n",
" return sample.mean()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"73.04819598338332"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sample_stat(sample)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Simulating experiment 1000 times"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def computing_sampling_distribution(n=100, iters=1000):\n",
" stats = [sample_stat(make_sample(n)) for i in range(iters)]\n",
" return np.array(stats)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sample_means = computing_sampling_distribution(n=100, iters=1000)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD7CAYAAACRxdTpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAO0ElEQVR4nO3dXYxc5X3H8e+vOOEiSWOoHde1TU0jE8m+iIO2KC1pG5eKAIpq3AsLVAWXpnLaQgtSqoqkF8kNUpLmRUFqkZxC40gpxE1w8YXVQKjbKFJ5WSNCMAThJlDsGHvzBkRREkH+vZgDHcyu92VmdrKPvx9pNOc855w5/0cz+5szz5wzm6pCktSWXxp3AZKk4TPcJalBhrskNchwl6QGGe6S1CDDXZIaNGu4J1mX5ECSR5McSnJd1/7hJEeTPNTdLuvb5gNJDid5PMm7RtkBSdKrZbbz3JOsBlZX1YNJ3gAcBC4HtgM/qqqPn7T+RuA24ALg14CvAOdV1YvDL1+SNJ1ls61QVceAY93080keA9acYpOtwO1V9VPg20kO0wv6/55pgxUrVtT69evnU7cknfYOHjz43apaOd2yWcO9X5L1wNuA+4ALgWuTXAVMAu+vqh/QC/57+zY7wqnfDFi/fj2Tk5PzKUWSTntJnppp2Zy/UE3yeuBLwPVV9RxwM/BmYDO9I/tPzLOonUkmk0xOTU3NZ1NJ0izmFO5JXkMv2D9fVXcAVNXxqnqxqn4OfIbe0AvAUWBd3+Zru7ZXqKpdVTVRVRMrV077qUKStEBzOVsmwC3AY1X1yb721X2rbQMe6ab3AVckOTPJucAG4P7hlSxJms1cxtwvBN4DfCPJQ13bB4Erk2wGCngSeB9AVR1Ksgd4FHgBuMYzZSRpcc3lbJmvAZlm0f5TbHMjcOMAdUmSBuAVqpLUIMNdkhpkuEtSgwx3SWrQvK5QlcblwN5DY9v3lm2bxrZvaaE8cpekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJatCs4Z5kXZIDSR5NcijJdV372UnuTvJEd39W154kNyU5nOThJOePuhOSpFeay5H7C8D7q2oj8HbgmiQbgRuAe6pqA3BPNw9wKbChu+0Ebh561ZKkU5o13KvqWFU92E0/DzwGrAG2Aru71XYDl3fTW4HPVc+9wPIkq4dduCRpZsvms3KS9cDbgPuAVVV1rFv0DLCqm14DPN232ZGu7RjSEnRg76Gx7HfLtk1j2a/aMOcvVJO8HvgScH1VPde/rKoKqPnsOMnOJJNJJqempuazqSRpFnMK9ySvoRfsn6+qO7rm4y8Nt3T3J7r2o8C6vs3Xdm2vUFW7qmqiqiZWrly50PolSdOYy9kyAW4BHquqT/Yt2gfs6KZ3AHf2tV/VnTXzduDZvuEbSdIimMuY+4XAe4BvJHmoa/sg8BFgT5L3Ak8B27tl+4HLgMPAj4Grh1mwJGl2s4Z7VX0NyAyLL5pm/QKuGbAuSdIAvEJVkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktSgufwnJullB/YeGncJkubAI3dJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lq0KzhnuTWJCeSPNLX9uEkR5M81N0u61v2gSSHkzye5F2jKlySNLO5HLl/FrhkmvZPVdXm7rYfIMlG4ApgU7fNPyY5Y1jFSpLmZtZwr6qvAt+f4+NtBW6vqp9W1beBw8AFA9QnSVqAQcbcr03ycDdsc1bXtgZ4um+dI12bJGkRLTTcbwbeDGwGjgGfmO8DJNmZZDLJ5NTU1ALLkCRNZ0HhXlXHq+rFqvo58Bn+f+jlKLCub9W1Xdt0j7GrqiaqamLlypULKUOSNIMFhXuS1X2z24CXzqTZB1yR5Mwk5wIbgPsHK1GSNF/LZlshyW3AO4EVSY4AHwLemWQzUMCTwPsAqupQkj3Ao8ALwDVV9eJIKpckzWjWcK+qK6dpvuUU698I3DhIUZKkwXiFqiQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGjTrP8iWNB4H9h4ay363bNs0lv1quDxyl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIi5iWoHFd3CJp6fDIXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQbOGe5Jbk5xI8khf29lJ7k7yRHd/VteeJDclOZzk4STnj7J4SdL05nLk/lngkpPabgDuqaoNwD3dPMClwIbuthO4eThlSpLmY9Zwr6qvAt8/qXkrsLub3g1c3tf+ueq5F1ieZPWQapUkzdFCx9xXVdWxbvoZYFU3vQZ4um+9I12bJGkRDfyFalUVUPPdLsnOJJNJJqempgYtQ5LUZ6Hhfvyl4Zbu/kTXfhRY17fe2q7tVapqV1VNVNXEypUrF1iGJGk6Cw33fcCObnoHcGdf+1XdWTNvB57tG76RJC2SWX84LMltwDuBFUmOAB8CPgLsSfJe4Clge7f6fuAy4DDwY+DqEdQsSZrFrOFeVVfOsOiiadYt4JpBi5IkDcYrVCWpQYa7JDXIcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoOWjbsASb9YDuw9NLZ9b9m2aWz7bo1H7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMG+m2ZJE8CzwMvAi9U1USSs4EvAOuBJ4HtVfWDwcqUJM3HMI7ct1TV5qqa6OZvAO6pqg3APd28JGkRjWJYZiuwu5veDVw+gn1Ikk5h0HAv4K4kB5Ps7NpWVdWxbvoZYNWA+5AkzdOgv+f+jqo6muRNwN1Jvtm/sKoqSU23YfdmsBPgnHPOGbAMSVK/gcK9qo529yeS7AUuAI4nWV1Vx5KsBk7MsO0uYBfAxMTEtG8Av+jG+U8NJOlUFjwsk+R1Sd7w0jRwMfAIsA/Y0a22A7hz0CIlSfMzyJH7KmBvkpce51+q6t+TPADsSfJe4Clg++BlSpLmY8HhXlXfAt46Tfv3gIsGKUqSNBivUJWkBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGrRs3AUM6sDeQ+MuQdKQjOvvecu2TWPZ7yh55C5JDTLcJalBhrskNchwl6QGLfkvVCVpUOM8MWNUX+Z65C5JDRpZuCe5JMnjSQ4nuWFU+5EkvdpIwj3JGcA/AJcCG4Erk2wcxb4kSa82qiP3C4DDVfWtqvoZcDuwdUT7kiSdZFThvgZ4um/+SNcmSVoEYztbJslOYGc3+6Mkj8/zIVYA3x1uVUvC6dhv+3z6OB37PUiff32mBaMK96PAur75tV3by6pqF7BroTtIMllVEwvdfqk6Hfttn08fp2O/R9XnUQ3LPABsSHJuktcCVwD7RrQvSdJJRnLkXlUvJLkW+DJwBnBrVfnzjZK0SEY25l5V+4H9o3p8BhjSWeJOx37b59PH6djvkfQ5VTWKx5UkjZE/PyBJDVoy4Z5keZIvJvlmkseS/FaSzUnuTfJQkskkF4y7zmFJ8pauXy/dnktyfZKzk9yd5Inu/qxx1zosp+jz33fP+8NJ9iZZPu5ah2mmfvctf3+SSrJijGUO1an6nOSvuuf7UJKPjbnUoTrFa3z4WVZVS+IG7Ab+rJt+LbAcuAu4tGu7DPjPcdc5or6fATxD75zWjwE3dO03AB8dd32L0OeLgWVd+0db7fPJ/e7m19E7MeEpYMW461uE53oL8BXgzG7Zm8Zd3yL1e+hZtiSO3JO8Efhd4BaAqvpZVf0QKOCXu9XeCHxnLAWO3kXA/1TVU/R+xmF3174buHxcRY3Yy32uqruq6oWu/V561020qv+5BvgU8Lf0Xuut6u/zXwAfqaqfAlTVibFWNlr9/R56li2V33M/F5gC/jnJW4GDwHXA9cCXk3yc3hDTb4+twtG6Aritm15VVce66WeAVeMpaeT6+9zvT4EvLHIti+nlfifZChytqq8nGW9Vo9X/XJ8H/E6SG4GfAH9TVQ+MrbLR6u/39Qw5y5bE2TJJJugdsV1YVfcl+TTwHL13uP+qqi8l2Q7srKo/GGetw9ZdBPYdYFNVHU/yw6pa3rf8B1XVzLg7vLrPfe1/B0wAf1RL4YU7T/39Bp4HDgAXV9WzSZ4EJqqqqUvzp3l9P0Kv338N/Ca9N/LfaO35nqbfNzHkLFsSwzL0fnjsSFXd181/ETgf2AHc0bX9K71fo2zNpcCDfSF3PMlqgO6+xY+tJ/eZJH8CvBv449b+0Pv09/vN9D6xfr0L9rXAg0l+dYz1jcLJz/UR4I7quR/4Ob3fXmnNyf0eepYtiXCvqmeAp5O8pWu6CHiU3jvf73Vtvw88MYbyRu1KXjk8sY/eC4Hu/s5Fr2j0XtHnJJfQG3f+w6r68diqGr2X+11V36iqN1XV+qpaTy/0zu/+Flpy8uv73+h9qUqS8+idPNHUp5XOyf0eepYtiWEZgCSbgX+i92R/C7ia3sfXT9P77uAnwF9W1cFx1ThsSV4H/C+9j6XPdm2/AuwBzqF3BsX2qvr++Kocrhn6fBg4E/het9q9VfXnYypxJKbr90nLn6SxYZkZnuvXArcCm4Gf0Rtz/4+xFTkCM/T7HQw5y5ZMuEuS5m5JDMtIkubHcJekBhnuktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUH/B6N55rv6SWhdAAAAAElFTkSuQmCC\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.hist(sample_means, color=COLOR2)\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "dab32048127b42c19533acee1dd2f960",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"interactive(children=(Dropdown(description='n', options=(10, 20, 50, 100, 200, 1000, 10000), value=10), Dropdo…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"@interact\n",
"def sim(n=[10,20,50,100, 200, 1000, 10000], iters=[100, 1000, 10000]):\n",
" sample_means = computing_sampling_distribution(n, iters)\n",
" mean = sample_means.mean()\n",
" std = sample_means.std()\n",
" plt.hist(sample_means, bins=30, color=COLOR2)\n",
" plt.axvline(mean, color=COLOR4)\n",
" plt.axvline(mean -3*std, color=COLOR5)\n",
" plt.axvline(mean +3*std, color=COLOR5)\n",
" \n",
" conf_int = np.percentile(sample_means, [2.5, 97.5]) # 95% confidence interval\n",
" plt.axvline(conf_int[0], color=COLOR1)\n",
" plt.axvline(conf_int[1], color=COLOR1)\n",
" plt.ylabel(\"count\")\n",
" plt.xlabel(f\"sample_means(n = {n})\")\n",
" plt.title(f\" iters={iters}, $\\mu_s$={mean:0.4f}, $\\sigma_s$={std:0.4f}\")\n",
" plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Application for Sim Monitor"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "2fd19e1890c74760a1145679d13dfda9",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Label(value='The values of slider1 and slider2 are synchronized')"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "6f284b9ba61844e1ade4f9040e1117f5",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"IntSlider(value=0, description='Slider 1')"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "89d75fed91214e58aa4e0143c1e54b3d",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"IntSlider(value=0, description='Slider 2')"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"\n",
"caption = widgets.Label(value='The values of slider1 and slider2 are synchronized')\n",
"sliders1, slider2 = widgets.IntSlider(description='Slider 1'),\\\n",
" widgets.IntSlider(description='Slider 2')\n",
"l = widgets.link((sliders1, 'value'), (slider2, 'value'))\n",
"display(caption, sliders1, slider2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Simple plot Linked to output widget"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib widget"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"widget_plot = widgets.Output()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"with widget_plot:\n",
" widget_plot.clear_output()\n",
" ax.clear()\n",
" fig, ax = plt.subplots(1,1)\n",
"# display(ax.figure)\n",
" plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "b59d335021404a2bbc3b1c5eb2c22c80",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Output()"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"widget_plot"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'ax' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-21-203552d8af35>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mNameError\u001b[0m: name 'ax' is not defined"
]
}
],
"source": [
"ax.plot(range(1, 100))\n",
"fig.canvas.draw()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ax.clear()\n",
"ax.plot(range(1, 20))\n",
"fig.canvas.draw()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# @interact\n",
"# def update_plot(n=2):\n",
"# ax.clear()\n",
"# ax.plot(np.linspace(1,100,100)**n)\n",
"# fig.canvas.draw()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"widget_plot"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"widget_pow = widgets.IntSlider(value=2,min=0, max=5)\n",
"widget_pow"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def update_plot(n=2):\n",
" ax.clear()\n",
" ax.plot(np.linspace(1,100,100)**n)\n",
" fig.canvas.draw()\n",
"\n",
"def handle_change(change):\n",
" update_plot(change.new)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'widget_pow' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-23-cc35b1b6381a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mwidget_pow\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobserve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhandle_change\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"value\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mNameError\u001b[0m: name 'widget_pow' is not defined"
]
}
],
"source": [
"widget_pow.observe(handle_change, \"value\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'widget_pow' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-24-cb580b1392d7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mwidgets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mVBox\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mwidget_plot\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwidget_pow\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mNameError\u001b[0m: name 'widget_pow' is not defined"
]
}
],
"source": [
"widgets.VBox([widget_plot, widget_pow])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Lognorm Application"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"widgets.SelectionSlider(\n",
" options=[1,2, 5, 6, 10],\n",
" value=1,\n",
" description='n',\n",
" disabled=False,\n",
" continuous_update=False,\n",
" orientation='horizontal',\n",
" readout=True\n",
")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def sample_stat(sample, kind='mean'):\n",
" if kind =='mean':\n",
" return sample.mean()\n",
" elif kind == 'coeff_variation':\n",
" return sample.mean()/sample.std()\n",
" elif kind == 'min':\n",
" return sample.min()\n",
" elif kind == 'max':\n",
" return sample.max()\n",
" elif kind == 'median':\n",
" return np.percentile(sample, 50)\n",
" elif kind == 'p10':\n",
" return np.percentile(sample, 10) \n",
" elif kind == 'p90':\n",
" return np.percentile(sample, 90)\n",
" elif kind == 'IQR':\n",
" return np.percentile(sample, 75) - np.percentile(sample, 25)\n",
" \n",
"def make_sample(rv, n=100):\n",
" sample = rv.rvs(n)\n",
" return sample\n",
"\n",
"def computing_sampling_distribution(rv, n=100, iters=1000, kind='mean'):\n",
" stats = [sample_stat(make_sample(rv, n), kind) for i in range(iters)]\n",
" return np.array(stats)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sample_stat(sample, kind='mean')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fig, axes = plt.subplots(nrows=2, ncols=2)\n",
"axes"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"ax0, ax1, ax2, ax3 = axes.flatten()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# def figure(figsize=None):\n",
"# 'Temporary workaround for traditional figure behaviour with the ipympl widget backend'\n",
"# fig = plt.figure()\n",
"# if figsize:\n",
"# w, h = figsize\n",
"# else:\n",
"# w, h = plt.rcParams['figure.figsize']\n",
"# fig.canvas.layout.height = str(h) + 'in'\n",
"# fig.canvas.layout.width = str(w) + 'in'\n",
"# return fig\n",
"\n",
"\n",
"def update_text(ax, x, y, s, align='right'):\n",
" ax.text(x, y, s,\n",
" horizontalalignment=align,\n",
" verticalalignment='top',\n",
" transform=ax.transAxes)\n",
" \n",
"# class KindRange(object):\n",
"# def __init__(self, kind, min_d, max_d):\n",
"# self.kind = kind\n",
"# self.min_d = min_d\n",
"# self.max_d = max_d\n",
"\n",
"class LogNormVisualizer(object):\n",
" \n",
" def __init__(self, shape, loc, median, xs=np.linspace(20, 160, 100)):\n",
" plt.close('all')\n",
" self.shape = shape\n",
" self.loc = loc\n",
" self.median = median\n",
" self.w_shape = widgets.FloatText(value=shape, description='shape',disabled=False)\n",
" self.w_loc = widgets.FloatText(value=loc, description='loc',disabled=False)\n",
" self.w_median = widgets.FloatText(value=median, description='median',disabled=False)\n",
" self.w_n = widgets.SelectionSlider(\n",
" options=[10,20,50,100, 200, 1000, 10000],\n",
" value=10,\n",
" description='n',\n",
" disabled=False,\n",
" continuous_update=False,\n",
" orientation='horizontal',\n",
" readout=True\n",
" )\n",
" \n",
" self.w_kind = widgets.Dropdown(\n",
" options=['mean', 'coeff_variation', 'min', 'max', 'median', 'p10', 'p90', 'IQR'],\n",
" value='mean',\n",
" description='Statisitics',\n",
" disabled=False,\n",
" continuous_update=False,\n",
" orientation='horizontal',\n",
" readout=True\n",
" )\n",
" self.kind = self.w_kind.value\n",
" self.w_iters = widgets.SelectionSlider(\n",
" options=[100,500, 1000, 5000, 10000],\n",
" value=100,\n",
" description='iters',\n",
" disabled=False,\n",
" continuous_update=False,\n",
" orientation='horizontal',\n",
" readout=True\n",
" )\n",
" self.rv = stats.lognorm(shape, loc, median)\n",
" self.w_rv = widgets.Output()\n",
" plt.close()\n",
" with self.w_rv:\n",
" self.w_rv.clear_output()\n",
" self.fig, axes = plt.subplots(nrows=4, ncols=1)\n",
" self.ax1, self.ax2, self.ax3, self.ax4 = axes\n",
" self.ax1.set_title(\"Log Normal Distribution\")\n",
" self.ax2.set_title(\"Statistics\")\n",
" self.ax3.set_title(\"Stat_Variation_n\")\n",
" self.ax3.set_title(\"Stat_Variation_iter\")\n",
" self.fig.canvas.toolbar_visible = False\n",
" self.fig.canvas.header_visible = False\n",
" self.fig.canvas.footer_visible = False\n",
"# self.fig.canvas.layout.width = '100%'\n",
"# self.fig.canvas.layout.height = '6in'\n",
"# self.fig.canvas.layout.width = '6in'\n",
" self.fig.canvas.resizable = True\n",
" self.fig.canvas.capture_scroll = True\n",
" self.fig.tight_layout()\n",
" \n",
" self.range_store = {}\n",
" self.w_range_min = widgets.FloatText(value=0, description='r_min',disabled=False)\n",
" self.w_range_max = widgets.FloatText(value=100, description='r_max',disabled=False)\n",
" self.w_range_reinit = widgets.Button(disabled=False, description='ReInitialize')\n",
" self.w_rv.layout.display = 'flex-grow'\n",
" self.xs = xs\n",
" self.sample_d = None\n",
" self.r_min = None\n",
" self.r_max = None\n",
" self.df = pd.DataFrame(columns=['n', 'iters', 'kind','mean_d','std_d'])\n",
" self.update_rv()\n",
" self.link_widgets()\n",
" \n",
"# self.update_rv_plot()\n",
"# self.update_stat_plot()\n",
" \n",
" def init_kind_range_store(self, kind, r_min, r_max):\n",
" self.update_range_store(kind, r_min, r_max)\n",
" self.w_range_min.value = r_min\n",
" self.w_range_max.value = r_max\n",
" \n",
" def update_range_store(self, kind, r_min, r_max):\n",
" self.range_store[kind] = (r_min, r_max)\n",
" \n",
" def link_widgets(self):\n",
" self.w_shape.observe(self.handle_shape_change, \"value\")\n",
" self.w_loc.observe(self.handle_loc_change, \"value\")\n",
" self.w_median.observe(self.handle_median_change,'value')\n",
" self.w_n.observe(self.handle_n_change, 'value')\n",
" self.w_iters.observe(self.handle_iters_change, 'value')\n",
" self.w_kind.observe(self.handle_kind_change, 'value')\n",
" self.w_range_min.observe(self.handle_w_range_min_change, 'value')\n",
" self.w_range_max.observe(self.handle_w_range_max_change, 'value')\n",
" self.w_range_reinit.on_click(self.handle_click)\n",
" \n",
"# plt.show()\n",
" \n",
" \n",
" def handle_click(self, b):\n",
" mean = self.sample_d.mean()\n",
" std = self.sample_d.std()\n",
" self.r_min = np.floor(mean-4*std)\n",
" self.r_max = np.ceil(mean+4*std)\n",
" self.init_kind_range_store(self.kind, self.r_min, self.r_max)\n",
" plt.show()\n",
" \n",
" def reset(self):\n",
" self.update_range_store(self.kind, self.r_min, self.r_max)\n",
" self.ax2.set_xlim(self.r_min, self.r_max)\n",
" plt.show()\n",
"# self.fig.canvas.draw()\n",
"# plt.draw()\n",
" \n",
" def handle_w_range_max_change(self, change):\n",
" self.r_min = self.w_range_min.value\n",
" self.r_max = change.new\n",
" self.reset()\n",
" \n",
" def handle_w_range_min_change(self, change):\n",
" self.r_min = change.new\n",
" self.r_max = self.w_range_max.value\n",
" self.reset()\n",
"\n",
"# plt.show()\n",
" \n",
" def handle_shape_change(self, change):\n",
" self.shape = change.new\n",
" self.update_rv()\n",
" \n",
" def handle_loc_change(self, change):\n",
" self.loc = change.new\n",
" self.update_rv()\n",
" \n",
" def handle_median_change(self, change):\n",
" self.median = change.new\n",
" self.update_rv()\n",
" \n",
" def handle_n_change(self, change):\n",
" self.n = change.new\n",
" self.update_stat_plot()\n",
" self.update_var_plot()\n",
" \n",
" def handle_iters_change(self, change):\n",
" self.iters = change.new\n",
" self.update_stat_plot()\n",
" self.update_var_plot()\n",
" \n",
" def handle_kind_change(self, change):\n",
" self.kind = change.new\n",
" self.update_stat_plot()\n",
" self.ax3.clear()\n",
" self.update_var_plot()\n",
" \n",
" def update_rv_plot(self):\n",
"# self.ax1.set_xlim([np.random.randint(100),100])\n",
" self.ax1.clear()\n",
" self.ax1.set_title(\"Log Normal Distribution\")\n",
" self.ys = self.rv.pdf(self.xs)\n",
" self.ax1.plot(self.xs, self.ys, linewidth=4, color=COLOR1)\n",
" update_text(self.ax1, 0.97, 0.95, f\"$\\sigma$={self.shape}\")\n",
" update_text(self.ax1, 0.97, 0.85, f\"$loc$={self.loc}\")\n",
" update_text(self.ax1, 0.97, 0.75, f\"$\\mu$={self.median}\")\n",
" plt.show()\n",
" \n",
" def update_stat_plot(self):\n",
" self.ax2.clear()\n",
" self.ax2.set_title(f\"Statistics[{self.w_kind.value}]\")\n",
" self.sample_d = computing_sampling_distribution(self.rv, self.w_n.value, \n",
" self.w_iters.value, \n",
" kind=self.w_kind.value)\n",
" mean = self.sample_d.mean()\n",
" std = self.sample_d.std()\n",
" self.r_min = np.floor(mean-4*std)\n",
" self.r_max = np.ceil(mean+4*std)\n",
" a,b = np.percentile(self.sample_d,[10, 90])\n",
" self.ax2.hist(self.sample_d, bins=30, color=COLOR2)\n",
" self.ax2.axvline(mean, color=COLOR4)\n",
" self.ax2.axvline(mean -3*std, color=COLOR5)\n",
" self.ax2.axvline(mean +3*std, color=COLOR5)\n",
" self.ax2.axvline(a, color=COLOR3)\n",
" self.ax2.axvline(b, color=COLOR3)\n",
" self.df.loc[self.df.shape[0]] = [self.w_n.value, self.w_iters.value, self.w_kind.value, mean, std]\n",
" if self.kind in self.range_store:\n",
" self.ax2.set_xlim(*self.range_store[self.kind])\n",
" pass\n",
" else:\n",
" self.init_kind_range_store(self.kind, self.r_min, self.r_max)\n",
" self.ax2.set_xlim(self.r_min, self.r_max)\n",
" update_text(self.ax2, 0.03, 0.95, f\"$\\sigma_d$={std:0.2f}\", align='left')\n",
" update_text(self.ax2, 0.03, 0.85, f\"$\\mu_d$={mean:0.2f}\", align='left')\n",
" update_text(self.ax2, 0.97, 0.95, f\"$p10_d$={a:0.2f}\")\n",
" update_text(self.ax2, 0.97, 0.85, f\"$p90_d$={b:0.2f}\")\n",
" plt.show()\n",
" \n",
" \n",
" def update_var_plot(self):\n",
"# self.df.plot.scatter('n', 'value', ax=self.ax3)\n",
" sel = self.df[self.df.kind==self.kind]\n",
" sel.plot.scatter(x='n', y='mean_d', s=sel['std_d']*200, ax=self.ax3, logx=True)\n",
" self.ax3.set_ylim(*self.range_store[self.kind])\n",
" sel.plot.scatter(x='iters', y='mean_d', s=sel['std_d']*200, ax=self.ax4, logx=True)\n",
" self.ax4.set_ylim(*self.range_store[self.kind])\n",
"# sns.scatterplot()\n",
" \n",
" plt.show()\n",
" \n",
" def update_rv(self):\n",
" self.rv = stats.lognorm(self.shape, self.loc, self.median)\n",
"# self.w_rv.clear_output()\n",
" self.update_rv_plot()\n",
" self.update_stat_plot()\n",
" self.update_var_plot()\n",
" \n",
" def view(self):\n",
"# with self.w_rv:\n",
"# display(self.ax.figure)\n",
" self.widget_setter_label = widgets.Label(\"Parameters\", position='center')\n",
" self.widget_setter = widgets.VBox([self.widget_setter_label,\n",
" widgets.HBox([self.w_shape, self.w_loc, self.w_median])])\n",
" self.widget_simcontrol = widgets.HBox([self.w_n, self.w_iters, self.w_kind])\n",
" self.range_control = widgets.HBox([self.w_range_min, self.w_range_max, self.w_range_reinit])\n",
" ui = widgets.VBox([self.widget_setter,self.widget_simcontrol,self.range_control, self.w_rv])\n",
" return ui"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "computing_sampling_distribution() got an unexpected keyword argument 'kind'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-26-34708152cec1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlnv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLogNormVisualizer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0.23\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m70.8\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;32m<ipython-input-25-7235e5af6dae>\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, shape, loc, median, xs)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mr_max\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'n'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'iters'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'kind'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'mean_d'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'std_d'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 95\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate_rv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 96\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlink_widgets\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;32m<ipython-input-25-7235e5af6dae>\u001b[0m in \u001b[0;36mupdate_rv\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 233\u001b[0m \u001b[0;31m# self.w_rv.clear_output()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 234\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate_rv_plot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 235\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate_stat_plot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 236\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate_var_plot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;32m<ipython-input-25-7235e5af6dae>\u001b[0m in \u001b[0;36mupdate_stat_plot\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 190\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0max2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclear\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 191\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0max2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_title\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Statistics[{self.w_kind.value}]\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 192\u001b[0;31m self.sample_d = computing_sampling_distribution(self.rv, self.w_n.value, \n\u001b[0m\u001b[1;32m 193\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mw_iters\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 194\u001b[0m kind=self.w_kind.value)\n",
"\u001b[0;31mTypeError\u001b[0m: computing_sampling_distribution() got an unexpected keyword argument 'kind'"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 576x648 with 4 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"lnv = LogNormVisualizer(0.23, 0, 70.8)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"lnv.rv.mean(), lnv.rv.std()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# df = lnv.df"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# df.loc[df.shape[0]] = [1,2,3,4]; df"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'lnv' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-27-73bcf06dbfee>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlnv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mview\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mNameError\u001b[0m: name 'lnv' is not defined"
]
}
],
"source": [
"lnv.view()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# lnv.df[lnv.df.kind=='mean'].plot.scatter(x='n',y='std_d', ax=lnv.ax3)\n",
"lnv.df[lnv.df.kind=='mean'].plot.scatter(x='n',y='std_d', s='mean_d', ax=lnv.ax3)\n",
"# lnv.df"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"np.percentile?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# plt.xlim?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"w = widgets.IntText()\n",
"l = widgets.IntText()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"t = 2\n",
"def handle_change(change):\n",
" t = change.new\n",
" l.value = t\n",
" \n",
"w.observe(handle_change, \"value\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "91ddcf2f5c5b4e4d8fd0c0838ee68cd9",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"VBox(children=(IntText(value=0), IntText(value=0)))"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"widgets.VBox([w,l])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# widgets.Label?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# display?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Estimating PI Computationally"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Area of circle => $\\pi r^2$\n",
"- Area of square of size 2r => 4r^2"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"rv = stats.uniform(-1,2)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"%matplotlib inline\n",
"plt.plot(np.linspace(1,10,10), rv.rvs(10))\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "669f8a9444e3497f9aff42694d8c27db",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"interactive(children=(IntSlider(value=500000, description='n', max=1000000, min=1), Output()), _dom_classes=('…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"@interact\n",
"def estimate_pi(n=(1,1000000)):\n",
" x = stats.uniform(-1,2)\n",
" y = stats.uniform(-1,2)\n",
" dist = np.sqrt( x.rvs(n)**2+y.rvs(n)**2)\n",
"# print(dist[:5])\n",
" in_circle = dist <= 1\n",
" pi = sum(in_circle)*4/n\n",
" return pi\n",
"# print(f\"Estimated PI {pi} with n:{n}\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"s = [estimate_pi(10000) for trials in range(1000)]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"sample = np.array(s)\n",
"plt.hist(sample, bins=40)\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(3.1407156, 0.017060112445115943, array([3.1116 , 3.16882]))"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sample.mean(), sample.std(), np.percentile(sample, [5,95])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Part 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"What if we don't know the underlying assumption?\n",
"- Take the Sample\n",
"- Generate Model for Population from Sample\n",
"- Calculate Sampling Statistics by running experiments on this model"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"sample = [1,2,3,4,5,2,1 ,4]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"n = len(sample)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([4, 1, 1, 3, 2, 5, 5, 5])"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.random.choice(sample, \n",
" n, \n",
" replace=True) # New sample from original sample , after this you can run experiment and calculate sampling statistics"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Resampling"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"class Resampler(object):\n",
" def __init__(self, sample, xlim=None, iters=1000):\n",
" self.sample = sample\n",
" self.n = len(sample)\n",
" self.iters = iters \n",
" \n",
" def resample(self):\n",
" new_sample = np.random.choice(self.sample, self.n, replace=True)\n",
" return new_sample\n",
" \n",
" \n",
" def sample_stat(self, sample):\n",
" return sample.mean()\n",
" \n",
" def computing_sampling_distribution(self):\n",
" stats = [self.sample_stat(self.resample()) for i in range(self.iters)]\n",
" return np.array(stats)\n",
" \n",
" def plot_summary_statistics_distribution(self):\n",
" fig, ax = plt.subplots(1)\n",
" stats = self.computing_sampling_distribution()\n",
" \n",
" mean = stats.mean()\n",
" SE = stats.std()\n",
" \n",
" conf_int = np.percentile(stats, [2.5, 97.5]) # 95% confidence interval\n",
" plt.axvline(mean, color=COLOR1)\n",
" plt.axvline(conf_int[0], color=COLOR1)\n",
" plt.axvline(conf_int[1], color=COLOR1)\n",
"# plt.xlim(mean-4std, )\n",
" plt.hist(stats, color=COLOR4)\n",
" plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(10,)"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# s = np.random.random([1, 100]).flatten()\n",
"s = weight.rvs(10)\n",
"rsample = Resampler(s, iters=1000)\n",
"rsample.sample.shape"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# stat = rsample.computing_sampling_distribution()\n",
"# stat.shape"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"rsample.plot_summary_statistics_distribution()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([3, 1, 3])"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
" np.random.choice([1,2,3],3, replace=True)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7feaabb10430>]"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.plot(s)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7feaabc22d60>]"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"xs = np.linspace(20, 160, 100)\n",
"plt.plot(weight.pdf(xs))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"scipy.stats._distn_infrastructure.rv_frozen"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(weight)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"list"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(sample)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"class StdResampler(Resampler):\n",
" def sample_stat(self, sample):\n",
" return sample.std()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1000,)"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"s = weight.rvs(1000)\n",
"rsample = StdResampler(s, iters=1000)\n",
"rsample.sample.shape"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"rsample.plot_summary_statistics_distribution()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Part 3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this section we will implement above for multiple group problems"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<scipy.stats._distn_infrastructure.rv_frozen at 0x7feaab9c58e0>"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mu1, sig1 = 178, 7.7\n",
"male_height = stats.norm(mu1, sig1); male_height"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<scipy.stats._distn_infrastructure.rv_frozen at 0x7feaab9ec4c0>"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mu2, sig2 = 163, 7.3\n",
"female_height = stats.norm(mu2, sig2); female_height"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"n = 1000\n",
"male_sample = male_height.rvs(1000)\n",
"female_sample = female_height.rvs(1000)\n",
"male_mean = male_height.mean()\n",
"female_mean = female_height.mean()\n",
"male_std = male_height.std()\n",
"female_std = female_height.std()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(8.426966292134832, 9.202453987730062)"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"difference = (mu1 - mu2)\n",
"\n",
"relative_difference_by_male = difference/mu1*100\n",
"relative_difference_by_female = difference/mu2*100\n",
"relative_difference_by_male, relative_difference_by_female"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"170.3"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"thresh = (male_mean*female_std+female_mean*male_std)/(male_std+female_std); thresh"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.163"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"male_overlap = sum((male_sample < thresh))/ len(male_sample)\n",
"male_overlap "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.139"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"female_overlap = sum((female_sample > thresh))/ len(female_sample);\n",
"female_overlap"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.15100000000000002"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"overlap = (male_overlap + female_overlap)/2; overlap"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"prob_superiority = sum(male_sample > female_sample)/(len(male_sample)+len(female_sample))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.929"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"prob_superiority = (male_sample > female_sample).mean()\n",
"prob_superiority"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def overlap(grp1_sample, grp2_sample):\n",
" \"\"\"\n",
" grp1: Control\n",
" grp2: Treatment\n",
" \"\"\"\n",
" \n",
"# grp1_sample = grp1.rvs(1000)\n",
"# grp2_sample = grp2.rvs(1000)\n",
" m1 = grp1_sample.mean() #grp1.mean()\n",
" m2 = grp2_sample.mean() #grp2.mean()\n",
" s1 = grp1_sample.std() #grp1.std()\n",
" s2 = grp2_sample.std() #grp1.std()\n",
" thresh = (m1*s2+m2*s1)/(s1+s2)\n",
" \n",
" grp1_overlap = sum(grp1_sample<thresh)/ len(grp1_sample)\n",
" grp2_overlap = sum(grp2_sample>thresh)/ len(grp2_sample)\n",
" misclassification_rate = (grp1_overlap+grp2_overlap)/2\n",
" return misclassification_rate\n",
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.166"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"grp1_sample = male_height.rvs(1000)\n",
"grp2_sample = female_height.rvs(1000)\n",
"\n",
"overlap(grp1_sample, grp2_sample)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def prob_superior(grp1_sample, grp2_sample):\n",
" # Assumes same size \n",
" assert len(grp1_sample) == len(grp2_sample)\n",
" return(grp1_sample>grp2_sample).mean()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.932"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"prob_superior(grp1_sample, grp2_sample)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"58.99469052969996"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"grp1_sample.var()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def cohen_effect(grp1_sample, grp2_sample):\n",
" diff = grp1_sample.mean() - grp2_sample.mean()\n",
" var1, var2 = grp1_sample.var(), grp2_sample.var()\n",
" n1, n2 = len(grp1_sample), len(grp2_sample)\n",
" pooled_var = (n1*var1+n2*var2)/(n1+n2)\n",
" d = diff/np.sqrt(pooled_var)\n",
" return d"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.9942476570475194"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"cohen_effect(grp1_sample, grp2_sample)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def color_data(inp, CI):\n",
" a, b = CI\n",
" t1 = inp< a\n",
" t2= inp>b \n",
" color_data = (t1+t2).astype(np.int)\n",
" return color_data\n",
"\n",
"class MultiGrpResampler(object):\n",
" def __init__(self, sample1, sample2, xlim=None, iters=1000, summary_stat='cohen'):\n",
" self.sample1 = sample1\n",
" self.sample2 = sample2\n",
" self.xlim = xlim\n",
" self.iters = iters\n",
" self.summary_stat = summary_stat\n",
" \n",
" def resample(self):\n",
" new_sample1 = np.random.choice(self.sample1, len(self.sample1), replace=True)\n",
" new_sample2 = np.random.choice(self.sample2, len(self.sample2), replace=True)\n",
" return new_sample1, new_sample2\n",
" \n",
" def calc_summary_stat(self, sample1, sample2):\n",
" if self.summary_stat == 'cohen':\n",
" return cohen_effect(sample1, sample2)\n",
" if self.summary_stat == 'overlap':\n",
" return overlap(sample1, sample2)\n",
" if self.summary_stat == 'prob_superiority':\n",
" return prob_superior(sample1, sample2)\n",
" \n",
" \n",
" def compute_sampling_distribution(self):\n",
" summary_stats = [self.calc_summary_stat(*self.resample()) for i in range(self.iters)]\n",
" return np.array(summary_stats)\n",
" \n",
" \n",
" def sampling_distribution(self):\n",
" summary_stats = self.compute_sampling_distribution()\n",
" \n",
" mean = summary_stats.mean()\n",
" std = summary_stats.std()\n",
" CI = np.percentile(summary_stats, [5, 95]) # 90% confidence interval\n",
" \n",
" return summary_stats, mean, std, CI\n",
" \n",
" \n",
" def plot_sampling_distribution(self):\n",
" summary_stats, mean, std, CI = self.sampling_distribution()\n",
" bins = 30\n",
"# hist_data = np.histogram(summary_stats, bins)[1]\n",
" x_sc = LinearScale()\n",
" y_sc = LinearScale()\n",
" col_sc = ColorScale(colors=['MediumSeaGreen', 'Red'])\n",
" y,edges = np.histogram(summary_stats, bins)\n",
" centers = 0.5*(edges[1:]+ edges[:-1])\n",
" cdata = np.array(col_sc.colors)[color_data(centers, CI)].tolist()\n",
" ax_x = Axis(scale=x_sc, tick_format='0.3f')\n",
" ax_y = Axis(scale=y_sc, orientation='vertical')\n",
" vline_mean = pltbq.vline(mean, stroke_width=2, colors=['orangered'], scales={'y': y_sc, 'x': x_sc, 'color': col_sc})\n",
" vline_a = pltbq.vline(CI[0], stroke_width=2, colors=['steelblue'], scales={'y': y_sc, 'x': x_sc, 'color': col_sc})\n",
" vline_b = pltbq.vline(CI[1], stroke_width=2, colors=['steelblue'], scales={'y': y_sc, 'x': x_sc, 'color': col_sc})\n",
" hist = Hist(sample=summary_stats, scales={'sample': x_sc, 'count': y_sc, 'color': col_sc}, bins=bins, colors=cdata)\n",
" fig = Figure(marks=[hist, vline_mean, vline_a, vline_b], axes=[ax_x, ax_y], padding=0, \n",
" title=f'Sampling Distribution {self.summary_stat}' )\n",
"# print(fig.marks[0].colors)\n",
" \n",
" return fig\n",
" \n",
" \n",
" \n",
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1.988103230980105, 0.05500478400582647, array([1.89740944, 2.07562714]))"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sample1 = male_height.rvs(1000)\n",
"sample2 = female_height.rvs(1000)\n",
"\n",
"rsampl = MultiGrpResampler(sample1, sample2,)\n",
"summary_stats, mean, std, CI = rsampl.sampling_distribution()\n",
"mean, std, CI"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def color_data(inp, CI):\n",
" a, b = CI\n",
" t1 = inp< a\n",
" t2= inp>b \n",
" color_data = (t1+t2).astype(np.int)\n",
" return color_data"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x_sc = LinearScale()\n",
"y_sc = LinearScale()\n",
"col_sc = ColorScale(colors=['MediumSeaGreen', 'Red'])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# hist = Hist(data=summary_stats, scales={'summary_statistics': x_sc, 'count':y_sc})\n",
"\n",
"hist = Hist(sample=summary_stats, scales={'sample': x_sc, 'count': y_sc, 'color': col_sc})\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(hist.midpoints)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Axis(scale=LinearScale(), tick_format='0.2f')"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ax_x = Axis(scale=x_sc, tick_format='0.2f')\n",
"ax_y = Axis(scale=y_sc, orientation='vertical')\n",
"ax_x"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([], dtype=int64)"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"color_data(hist.midpoints, CI)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[]"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.array(col_sc.colors)[color_data(hist.midpoints, CI)].tolist()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[]"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"hist.bins = 30\n",
"hist.colors = np.array(col_sc.colors)[color_data(hist.midpoints, CI)].tolist()\n",
"hist.colors"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Figure(marks=[hist], axes=[ax_x, ax_y], padding=0, title='Sampling Distribution' )"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(Lines(colors=['orangered'], interactions={'hover': 'tooltip'}, preserve_domain={'x': False, 'y': True}, scales={'y': LinearScale(allow_padding=False, max=1.0, min=0.0), 'x': LinearScale()}, scales_metadata={'x': {'orientation': 'horizontal', 'dimension': 'x'}, 'y': {'orientation': 'vertical', 'dimension': 'y'}, 'color': {'dimension': 'color'}}, tooltip_style={'opacity': 0.9}, x=array([2.12200944, 2.12200944]), y=array([0, 1])),\n",
" Lines(colors=['steelblue'], interactions={'hover': 'tooltip'}, preserve_domain={'x': False, 'y': True}, scales={'y': LinearScale(allow_padding=False, max=1.0, min=0.0), 'x': LinearScale()}, scales_metadata={'x': {'orientation': 'horizontal', 'dimension': 'x'}, 'y': {'orientation': 'vertical', 'dimension': 'y'}, 'color': {'dimension': 'color'}}, tooltip_style={'opacity': 0.9}, x=array([2.02652263, 2.02652263]), y=array([0, 1])),\n",
" Lines(colors=['steelblue'], interactions={'hover': 'tooltip'}, preserve_domain={'x': False, 'y': True}, scales={'y': LinearScale(allow_padding=False, max=1.0, min=0.0), 'x': LinearScale()}, scales_metadata={'x': {'orientation': 'horizontal', 'dimension': 'x'}, 'y': {'orientation': 'vertical', 'dimension': 'y'}, 'color': {'dimension': 'color'}}, tooltip_style={'opacity': 0.9}, x=array([2.21439821, 2.21439821]), y=array([0, 1])))"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"vline_mean = pltbq.vline(mean, stroke_width=2, colors=['orangered'], scales={'y': y_sc, 'x': x_sc})\n",
"vline_a = pltbq.vline(CI[0], stroke_width=2, colors=['steelblue'], scales={'y': y_sc, 'x': x_sc})\n",
"vline_b = pltbq.vline(CI[1], stroke_width=2, colors=['steelblue'], scales={'y': y_sc, 'x': x_sc})\n",
"vline_mean, vline_a, vline_b"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "5a314026204c493baabe02e7ef25bab8",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Figure(axes=[Axis(scale=LinearScale(), tick_format='0.2f'), Axis(orientation='vertical', scale=LinearScale())]…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"Figure(marks=[hist, vline_mean, vline_a, vline_b], axes=[ax_x, ax_y], padding=0, title='Sampling Distribution 2' )"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Function Call"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['Red',\n",
" 'Red',\n",
" 'Red',\n",
" 'Red',\n",
" 'Red',\n",
" 'Red',\n",
" 'Red',\n",
" 'Red',\n",
" 'MediumSeaGreen',\n",
" 'MediumSeaGreen',\n",
" 'MediumSeaGreen',\n",
" 'MediumSeaGreen',\n",
" 'MediumSeaGreen',\n",
" 'MediumSeaGreen',\n",
" 'MediumSeaGreen',\n",
" 'MediumSeaGreen',\n",
" 'MediumSeaGreen',\n",
" 'MediumSeaGreen',\n",
" 'MediumSeaGreen',\n",
" 'MediumSeaGreen',\n",
" 'MediumSeaGreen',\n",
" 'MediumSeaGreen',\n",
" 'Red',\n",
" 'Red',\n",
" 'Red',\n",
" 'Red',\n",
" 'Red',\n",
" 'Red',\n",
" 'Red',\n",
" 'Red']"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"bins=30\n",
"y,edges = np.histogram(summary_stats, bins)\n",
"centers = 0.5*(edges[1:]+ edges[:-1])\n",
"cdata = np.array(col_sc.colors)[color_data(centers, CI)].tolist()\n",
"cdata"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "c3d580e9954f4abf98b4712e1445e70b",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Figure(axes=[Axis(scale=LinearScale(), tick_format='0.3f'), Axis(orientation='vertical', scale=LinearScale())]…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"n = 100000\n",
"sample1 = male_height.rvs(n)\n",
"sample2 = female_height.rvs(1000)\n",
"\n",
"rsampl = MultiGrpResampler(sample1, sample2,summary_stat='cohen')\n",
"fig = rsampl.plot_sampling_distribution()\n",
"# fig.marks[0].colors = cdata\n",
"fig"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Hist(bins=30, colors=['Red', 'Red', 'Red', 'Red', 'Red', 'Red', 'Red', 'MediumSeaGreen', 'MediumSeaGreen', 'MediumSeaGreen', 'MediumSeaGreen', 'MediumSeaGreen', 'MediumSeaGreen', 'MediumSeaGreen', 'MediumSeaGreen', 'MediumSeaGreen', 'MediumSeaGreen', 'MediumSeaGreen', 'MediumSeaGreen', 'MediumSeaGreen', 'MediumSeaGreen', 'MediumSeaGreen', 'Red', 'Red', 'Red', 'Red', 'Red', 'Red', 'Red', 'Red', 'Red'], interactions={'hover': 'tooltip'}, scales={'sample': LinearScale(), 'count': LinearScale(), 'color': ColorScale(colors=['MediumSeaGreen', 'Red'])}, scales_metadata={'sample': {'orientation': 'horizontal', 'dimension': 'x'}, 'count': {'orientation': 'vertical', 'dimension': 'y'}}, tooltip_style={'opacity': 0.9})"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fig.marks[0]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"30"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fig.marks[0].bins"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "e5098cbc220e42d3af3ec55604635f17",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Figure(axes=[Axis(scale=LinearScale(), tick_format='0.2f'), Axis(orientation='vertical', scale=LinearScale())]…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"fig"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"summary_stat = 'cohen'\n",
"summary_stats, mean, std, CI = rsampl.sampling_distribution()\n",
"x_sc = LinearScale()\n",
"y_sc = LinearScale()\n",
"col_sc = ColorScale(colors=['MediumSeaGreen', 'Red'])\n",
"ax_x = Axis(scale=x_sc, tick_format='0.2f')\n",
"ax_y = Axis(scale=y_sc, orientation='vertical')\n",
"hist = Hist(sample=summary_stats, scales={'sample': x_sc, 'count': y_sc, 'color': col_sc}, bins=30)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['steelblue']"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"hist.colors"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"vline_mean = pltbq.vline(mean, stroke_width=2, colors=['orangered'], scales={'y': y_sc, 'x': x_sc})\n",
"vline_a = pltbq.vline(CI[0], stroke_width=2, colors=['steelblue'], scales={'y': y_sc, 'x': x_sc})\n",
"vline_b = pltbq.vline(CI[1], stroke_width=2, colors=['steelblue'], scales={'y': y_sc, 'x': x_sc})\n",
"fig = Figure(marks=[hist, vline_mean, vline_a, vline_b], axes=[ax_x, ax_y], padding=0, \n",
" title=f'Sampling Distribution {summary_stat}' )"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "61cb33c239b240e98b097a5dab9a904b",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Figure(axes=[Axis(scale=LinearScale(), tick_format='0.2f'), Axis(orientation='vertical', scale=LinearScale())]…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"fig"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[]"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"hist.bins = 30\n",
"hist.colors = np.array(col_sc.colors)[color_data(hist.midpoints, CI)].tolist()\n",
"hist.colors"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "61cb33c239b240e98b097a5dab9a904b",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Figure(axes=[Axis(scale=LinearScale(), tick_format='0.2f'), Axis(orientation='vertical', scale=LinearScale())]…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"fig\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "133e47d4ac3b4dac95cf3a8bdb3bfbcb",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Figure(axes=[Axis(scale=LinearScale(), tick_format='0.2f'), Axis(orientation='vertical', scale=LinearScale())]…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"summary_stat = 'cohen'\n",
"summary_stats, mean, std, CI = rsampl.sampling_distribution()\n",
"x_sc = LinearScale()\n",
"y_sc = LinearScale()\n",
"col_sc = ColorScale(colors=['MediumSeaGreen', 'Red'])\n",
"ax_x = Axis(scale=x_sc, tick_format='0.2f')\n",
"ax_y = Axis(scale=y_sc, orientation='vertical')\n",
"hist = Hist(sample=summary_stats, scales={'sample': x_sc, 'count': y_sc, 'color': col_sc}, bins=30)\n",
"# hist.bins = 30\n",
"with hist.hold_sync():\n",
" hist.colors = np.array(col_sc.colors)[color_data(hist.midpoints, CI)].tolist()\n",
"vline_mean = pltbq.vline(mean, stroke_width=2, colors=['orangered'], scales={'y': y_sc, 'x': x_sc})\n",
"vline_a = pltbq.vline(CI[0], stroke_width=2, colors=['steelblue'], scales={'y': y_sc, 'x': x_sc})\n",
"vline_b = pltbq.vline(CI[1], stroke_width=2, colors=['steelblue'], scales={'y': y_sc, 'x': x_sc})\n",
"fig = Figure(marks=[hist, vline_mean, vline_a, vline_b], axes=[ax_x, ax_y], padding=0, \n",
" title=f'Sampling Distribution {summary_stat}' )\n",
"fig"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(array([3, 1, 1]), array([ 3. , 8.33333333, 13.66666667, 19. ]))"
]
},
"execution_count": null,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.histogram([12,3,4,5, 19], bins=3)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"np.histogram?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}