{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Probability Distributions as Parameters\n",
    "\n",
    "In most cases, augmentation that employs simple uniform distributions is enough to produce good results. E.g. in the case of rotation via affine transormations, one could provide a uniform distribution `(-30, 30)`, which would lead to images being rotated by a random value between `-30` degrees and `+30` degrees. In `imgaug`, using uniform distributions can usually be achieved via tuples, e.g. `Affine(rotate=(-30, 30))`. This pattern is supported by most augmenters. Similarly, scalar values can be used to avoid stochasticity (e.g. `Affine(rotate=-30)` will always rotate by `-30` degrees) and lists can be used to sample random values from a predefined set of valid values (e.g. `Affine(rotate=[-30, -15])` will always rotate by either `-30` degrees or `-15` degrees).\n",
    "\n",
    "Sometimes it can be sensible to use probability distributions that differ from the described ones. For instance, one might want to rotate images by a value sampled from a gaussia or laplace distribution. For these use cases, the parameters in `imgaug.parameters` exist. After instantiating one of these, they can be used instead of the above described scalar values, tuples or lists. E.g. `Affine(rotate=imgaug.parameters.Normal(0, 5.0))` would rotate images by a value sampled from the gaussian distribution `N(0, 5.0)`. Similar parameters exist for many common probability distributions, such as Laplace, Poisson, Beta or Truncted Normal distributions.\n",
    "\n",
    "Probability distributions available in `imgaug.parameters` are (their interfaces are largely identical to the ones in [numpy.random](https://docs.scipy.org/doc/numpy-1.15.4/reference/routines.random.html)):\n",
    "* `Deterministic(value)` (mixed): Always returns `value`, i.e. is not stochastic.\n",
    "* `DeterministicList(values)` (mixed): Fills the output array by iterating over `values`. If the end of `values` is reached, it restarts again at the first component of `values`.\n",
    "* `Choice(a, replace=True, p=None)` (mixed): Always returns one of the values in `a`.\n",
    "* `Binomial(p)` (discrete)\n",
    "* `DiscreteUniform(a, b)` (discrete)\n",
    "* `Poisson(lam)` (discrete)\n",
    "* `Normal(loc, scale)` (continuous)\n",
    "* `TruncatedNormal(loc, scale, low=-inf, high=+inf)` (continuous)\n",
    "* `Laplace(loc, scale)` (continuous)\n",
    "* `ChiSquare(df)` (continuous)\n",
    "* `Weibull(a)` (continuous)\n",
    "* `Uniform(a, b)` (continuous)\n",
    "* `Beta(alpha, beta)` (continuous)\n",
    "\n",
    "`imgaug.parameters` also contains some \"helper\" parameters. These wrap other parameters (e.g. one of the probability distributions above) and modify the sampled values.\n",
    "* `FromLowerResolution(other_param, size_percent=None, size_px=None, method=\"nearest\", min_size=1)`: A parameter intended for cases when random values are sampled in 2D shape, i,e, `(height, width)` or `(height, width, channels)`. In these cases, this parameter will change the sampling shape and instead sample from a lower resolution grid and then upscale. This can lead to coarser sampled values.\n",
    "* `Clip(other_param, minval=None, maxval=None)`: Similar to `numpy.clip()`.\n",
    "* `Discretize(other_param)`: Converts outputs of `other_param` to integers (includes rounding).\n",
    "* `Absolute(other_param)`: Takes the absolute value of all parameters sampled from `other_param`.\n",
    "* `RandomSign(other_param, p_positive=0.5)`: Mixes up the signs, so that roughly `p_positive` of all values end up being positive values.\n",
    "* `ForceSign(other_param, positive, mode=\"reroll\", reroll_count_max=2)`: Assures that all values sampled from `other_param` are either positive (`positive=True`) or negative (`positive=False`). This is either done using a naive sign flip (`mode=\"invert\"`) or by re-rolling values with undesired signs up to `reroll_count_max` times until they match the desired sign (after `reroll_count_max` times the parameter falls back to `mode=\"invert\"`).\n",
    "* `Positive(other_param, mode=\"reroll\", reroll_count_max=2)`: Shortcut for `ForceSign(..., positive=True, ...)`.\n",
    "* `Negative(other_param, mode=\"reroll\", reroll_count_max=2)`: Shortcut for `ForceSign(..., positive=False, ...)`.\n",
    "\n",
    "There are also a few arithmetic parameters. While these can be used, stochastic parameters also support arithmetic operators. E.g. `Add(Normal(0, 2), 5)` is the same as `Normal(0, 2) + 5` and will effectively lead to values sampled from `N(5, 2)`. The arithmetic parameters are listed below. In all cases, both `other_param` and `val` are expected to be stochastic parameters or scalar values. If `elementwise` is set to `False`, then only one value will be sampled from `val`, otherwise as many as there are in `other_param`.\n",
    "* `Multiply(other_param, val, elementwise=False)`\n",
    "* `Divide(other_param, val, elementwise=False)`\n",
    "* `Add(other_param, val, elementwise=False)`\n",
    "* `Subtract(other_param, val, elementwise=False)`\n",
    "* `Power(other_param, val, elementwise=False)`\n",
    "\n",
    "Lastly, there are noise related parameters. These deal with generating or modifying noise masks, i.e. usually 2D arrays with random values between `0.0` and `1.0`.\n",
    "* `IterativeNoiseAggregator(other_param, iterations=(1, 3), aggregation_method=[\"max\", \"avg\"])`: Generates a few noise masks via `other_param` and combines them using an aggregation method.\n",
    "* `Sigmoid(other_param, threshold=(-10, 10), activated=True)`: Applies a sigmoid function to a noise mask, making some values more pronounced than others.\n",
    "* `SimplexNoise(size_px_max=(2, 16), upscale_method=[\"linear\", \"nearest\"])`: Generates noise using a simplex noise method.\n",
    "* `FrequencyNoise(exponent=(-4, 4), size_px_max=(4, 32), upscale_method=[\"linear\", \"nearest\"])`: Generates noise by putting more or less weight on some components in frequency space.\n",
    "\n",
    "For more details about each of the listed parameters, see the [API](https://imgaug.readthedocs.io/en/latest/source/api_parameters.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating and Using Stochastic Parameters\n",
    "\n",
    "Let's now start using some stochastic parameters. First, we take a look at the automatic conversion from augmenter inputs to parameters. As mentioned initially, scalar values are interpreted as non-stochastic/deterministic values (and become `imgaug.parameters.Deterministic`), tuples of form `(a, b)` are usually interpreted as uniform distributions (and become `imgaug.parameters.Uniform` or `imgaug.parameters.DiscreteUniform`) and lists are interpreted as sets of values to sample from (and become `imgaug.parameters.choice`).\n",
    "\n",
    "The example below creates an augmenter `Multiply` and uses once a scalar value, once a tuple and once a list. As the printed messages show, these inputs are automatically converted to stochastic parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Deterministic(int 1)\n",
      "Uniform(Deterministic(float 0.50000000), Deterministic(float 1.50000000))\n",
      "Choice(a=[0.5, 1.0, 1.5], replace=True, p=None)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import imgaug as ia\n",
    "from imgaug import augmenters as iaa\n",
    "from imgaug import parameters as iap\n",
    "%matplotlib inline\n",
    "np.set_printoptions(precision=2, linewidth=125, suppress=False)\n",
    "ia.seed(1)\n",
    "\n",
    "aug = iaa.Multiply(mul=1)\n",
    "print(aug.mul)\n",
    "\n",
    "aug = iaa.Multiply(mul=(0.5, 1.5))\n",
    "print(aug.mul)\n",
    "\n",
    "aug = iaa.Multiply(mul=[0.5, 1.0, 1.5])\n",
    "print(aug.mul)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of using the automatic conversion, one can also directly provide a stochastic parameter, e.g. a deterministic value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Deterministic(int 1)\n"
     ]
    }
   ],
   "source": [
    "aug = iaa.Multiply(mul=iap.Deterministic(1))\n",
    "print(aug.mul)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All stochastic parameters offer a method `draw_samples(size, [random_state])`, which can be used to sample random values from the parameter. The resulting array has shape `size`. Note that `random_state` is quite tolerant and also accepts integer seeds. The below example shows the usage with `Deterministic`, which always produces the same output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 1 1 1 1 1 1 1 1]\n",
      "[1 1 1 1 1 1 1 1 1 1]\n",
      "[1 1 1 1 1 1 1 1 1 1]\n",
      "[1 1 1 1 1 1 1 1 1 1]\n"
     ]
    }
   ],
   "source": [
    "print(iap.Deterministic(1).draw_samples(10))\n",
    "print(iap.Deterministic(1).draw_samples(10, random_state=1))\n",
    "print(iap.Deterministic(1).draw_samples(10, random_state=1))\n",
    "print(iap.Deterministic(1).draw_samples(10, random_state=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`DeterministicList` can be used if a sequence of multiple values are supposed to be deterministically sampled:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 1 2 3 1 2 3 1]\n",
      "[1 2 3 1 2 3 1 2 3 1]\n",
      "[1 2 3 1 2 3 1 2 3 1]\n",
      "[1 2 3 1 2 3 1 2 3 1]\n"
     ]
    }
   ],
   "source": [
    "print(iap.DeterministicList([1, 2, 3]).draw_samples(10))\n",
    "print(iap.DeterministicList([1, 2, 3]).draw_samples(10, random_state=1))\n",
    "print(iap.DeterministicList([1, 2, 3]).draw_samples(10, random_state=1))\n",
    "print(iap.DeterministicList([1, 2, 3]).draw_samples(10, random_state=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same example using `Uniform`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.83 0.83 0.88 0.29 0.2  0.79 0.34 0.31 0.83 0.56]\n",
      "[0.43 0.76 0.83 0.83 0.88 0.29 0.2  0.79 0.34 0.31]\n",
      "[0.43 0.76 0.83 0.83 0.88 0.29 0.2  0.79 0.34 0.31]\n",
      "[0.89 0.09 0.61 0.64 0.33 0.8  0.19 0.1  0.01 0.7 ]\n"
     ]
    }
   ],
   "source": [
    "print(iap.Uniform(0, 1.0).draw_samples(10))\n",
    "print(iap.Uniform(0, 1.0).draw_samples(10, random_state=1))\n",
    "print(iap.Uniform(0, 1.0).draw_samples(10, random_state=1))\n",
    "print(iap.Uniform(0, 1.0).draw_samples(10, random_state=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same example using `Choice`, which samples values by picking randomly from a set of allowed values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.5 0.5 0.  0.5 0.  1.  0.  0.5 0.  1. ]\n",
      "[0.5 1.  0.5 0.5 0.5 0.5 1.  1.  1.  1. ]\n",
      "[0.5 1.  0.5 0.5 0.5 0.5 1.  1.  1.  1. ]\n",
      "[0.5 1.  0.  0.  0.  1.  0.  0.  0.5 0.5]\n"
     ]
    }
   ],
   "source": [
    "print(iap.Choice([0, 0.5, 1.0]).draw_samples(10))\n",
    "print(iap.Choice([0, 0.5, 1.0]).draw_samples(10, random_state=1))\n",
    "print(iap.Choice([0, 0.5, 1.0]).draw_samples(10, random_state=1))\n",
    "print(iap.Choice([0, 0.5, 1.0]).draw_samples(10, random_state=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`size` in `draw_samples(size, ...)` can be a scalar value or a tuple of values representing an array shape:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 1 1 1 1 0 0 1 0 0 1 1 0 1 1]\n",
      "[[0 0 1 1]\n",
      " [1 1 0 0]\n",
      " [1 0 0 1]\n",
      " [1 0 1 1]]\n"
     ]
    }
   ],
   "source": [
    "print(iap.Binomial(p=0.5).draw_samples(4*4, random_state=1))\n",
    "print(iap.Binomial(p=0.5).draw_samples((4, 4), random_state=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned at the start of the document, stochastic parameters support basic arithmetic operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 2 2 2 2 2 2 2 2 2]\n",
      "[0 0 0 0 0 0 0 0 0 0]\n",
      "[0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5]\n",
      "[2 2 2 2 2 2 2 2 2 2]\n",
      "[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "print((iap.Deterministic(1) + 1).draw_samples(10))\n",
    "print((iap.Deterministic(1) - 1).draw_samples(10))\n",
    "print((iap.Deterministic(1) / 2).draw_samples(10))\n",
    "print((iap.Deterministic(1) * 2).draw_samples(10))\n",
    "print((iap.Deterministic(1) ** 2).draw_samples(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The arithmetic operators can also be used with more complex probability distributions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 2 2 3 3 2 3 3 1]\n",
      "[6 6 6 2 4 2 2 2 2 2]\n"
     ]
    }
   ],
   "source": [
    "print(iap.Choice([1, 2, 3]).draw_samples(10))\n",
    "print((iap.Choice([1, 2, 3]) * 2).draw_samples(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Performing arithmetic operations with stochastic parameters returns multiple parameters that are wrapped in an arithmetic parameter, i.e. `param1 + param2 = Add(param1, param2)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiply(Choice(a=[1, 2, 3], replace=True, p=None), Deterministic(int 2), False)\n"
     ]
    }
   ],
   "source": [
    "print(iap.Choice([1, 2, 3]) * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This detail must be kept in mind when calling the result with a `random_state` argument, as it will provide a random state -- in the above example -- to `Multiply`, which then derives two new random states from the initial one and provides them to the first and second parameter. These two derived random states are different from the initial random state. As a result `param1.draw_samples(1, np.random.RandomState(1))` can lead to different sampled values than `(param1 + 0).draw_samples(1, np.random.RandomState(1))`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Discrete Random Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of the examples above used either continuous probability distributions, which return float values, or mixed ones, which return data of various types. There are also three discrete probability distributions available, which return integer values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 1 2 1 2 1 2 2 1 1 2 2 3 0 3 3 1 3 2 0]\n",
      "[0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 1 1 0 1 0]\n",
      "[1 0 0 0 2 2 1 0 0 1 1 0 2 2 2 3 0 4 0 2]\n"
     ]
    }
   ],
   "source": [
    "print(iap.DiscreteUniform(0, 3).draw_samples(20))\n",
    "print(iap.Binomial(p=0.3).draw_samples(20))\n",
    "print(iap.Poisson(lam=1).draw_samples(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any continuous probability distribution can be turned into a discrete one using `Discretize`, which rounds float values and then converts them to the nearest integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Continuous: [-0.43  1.47  0.   -2.34 -0.5  -1.33 -2.66  0.64  0.41  0.29  0.19 -0.72 -1.61  2.14 -0.43  0.6   1.78  0.29 -1.46 -0.45]\n",
      "Discrete:   [ 1 -1 -1  0  0 -2 -1 -1  1  0  0  0  0 -2  0 -1 -1  1 -2  1]\n"
     ]
    }
   ],
   "source": [
    "print(\"Continuous:\", iap.Normal(0.0, 1.0).draw_samples(20))\n",
    "print(\"Discrete:  \", iap.Discretize(iap.Normal(0.0, 1.0)).draw_samples(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In case you have to limit the value range of a probability distribution, `Clip` can be used, which behaves similarly to numpy's `clip` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.02 -1.1  -0.7  -0.38 -1.43 -0.15  0.46 -0.09  0.95  1.99 -0.11 -0.47  1.19 -1.4  -1.16]\n",
      "[ 0.96  0.11 -0.49  1.93 -1.   -1.   -1.   -0.14 -1.    0.26  1.96  0.92 -0.97  1.    1.39]\n",
      "[ 1.   -0.09 -1.97 -0.51 -0.94  1.   -0.96 -0.9  -1.25  1.    0.38  0.11 -1.62  1.   -0.45]\n",
      "[ 1.    1.   -0.91  0.1  -0.25  1.   -1.   -0.1   0.94 -0.64 -1.    0.27  0.3  -0.45 -0.5 ]\n"
     ]
    }
   ],
   "source": [
    "uniform = iap.Uniform(-2, 2)\n",
    "print(uniform.draw_samples(15))\n",
    "print(iap.Clip(uniform, -1, None).draw_samples(15))\n",
    "print(iap.Clip(uniform, None, 1).draw_samples(15))\n",
    "print(iap.Clip(uniform, -1, 1).draw_samples(15))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note however that `Clip` can result in distorted probability densities due to all values below/above the defined minimum/maximum being projected onto the minimum/maximum value. The following plot uses a histogram to visualize the probability density after applying `Clip` to `Uniform`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot = iap.Clip(uniform, -1, 1).draw_distribution_graph()\n",
    "plot_large = ia.imresize_single_image(plot, 2.0)\n",
    "ia.imshow(plot_large)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Changing signs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Several helper parameters exist to modify the sign of samples random values. The easiest way to flip signs is simple arithmetic, here used to turn the positive samples from a poisson distribution to negative ones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 1 2 0 1 0 0 1 0 1 1 0 1 2 1 0 0 1 0]\n",
      "[-2  0  0 -1 -1  0 -2  0 -1  0 -3  0  0 -3 -1 -2  0  0  0 -1]\n"
     ]
    }
   ],
   "source": [
    "print(iap.Poisson(lam=1).draw_samples(20))\n",
    "print((-1) * iap.Poisson(lam=1).draw_samples(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In case you only want positive values, `Absolute` can be used, here applied to a gaussian distribution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.37 -1.29  0.47  0.84  1.3   0.4   1.72  0.94  0.12  0.35 -1.78 -0.67 -0.16 -0.85 -1.94]\n",
      "[0.44 0.35 1.24 0.6  0.46 0.33 0.14 0.22 0.02 0.4  0.95 0.75 0.82 1.19 0.28]\n"
     ]
    }
   ],
   "source": [
    "print(iap.Normal(0, 1.0).draw_samples(15))\n",
    "print(iap.Absolute(iap.Normal(0, 1.0)).draw_samples(15))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To force a specific fraction of random samples to have positive signs, the helper `RandomSign(param, p_positive)` can be used. It first turns all values to positive ones and then flips the sign of `(1-p_positive)` percent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 random samples:  [ 5.04e-01  1.19e+00  1.24e-01  2.13e+00  1.28e-03  1.18e+00  9.62e-01 -1.40e-02 -1.17e-01  8.48e-01  9.82e-01  4.78e-01\n",
      "  1.09e+00  2.77e-01  6.09e-01]\n",
      "Positive samples in 10000 random samples:  7956\n"
     ]
    }
   ],
   "source": [
    "rnd_sign = iap.RandomSign(iap.Normal(0, 1.0), p_positive=0.8)\n",
    "print(\"15 random samples: \", rnd_sign.draw_samples(15))\n",
    "print(\"Positive samples in 10000 random samples: \", np.sum(rnd_sign.draw_samples(10000) > 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another helper is `ForceSign`, which has two arguments: `positive`, which controls whether the output values are supposed to have positive or negative signs, and `mode`, which controls how the signs are flipped. Using `mode=\"invert\"` results in naively flipping signs by multiplying with `-1`, which can distort the probability distribution and lead to density in value ranges where there was previously no density. `mode=\"reroll\"` will re-sample only values with wrong signs and will therefore keep the density of the probability distribution unchanged (except for the removal of positive/negative values)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ -2  -2  -5 -10  -2 -10  -5  -5  -2  -2  -1  -1  -2  -1 -10]\n",
      "[-2 -1 -1 -1 -2 -2 -1 -1 -1 -1 -2 -1 -2 -2 -1]\n"
     ]
    }
   ],
   "source": [
    "force_sign_invert = iap.ForceSign(iap.Choice([-2, -1, 5, 10]), positive=False, mode=\"invert\")\n",
    "force_sign_reroll = iap.ForceSign(iap.Choice([-2, -1, 5, 10]), positive=False, mode=\"reroll\")\n",
    "print(force_sign_invert.draw_samples(15))\n",
    "print(force_sign_reroll.draw_samples(15))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The below example generates a plot using `ForceSign` with naive `mode=\"invert\"` applied to a gaussian distribution. All negative values are simply flipped, leading to more probability density in the interval `[0, 4]` than in `[4, 8]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "param = iap.ForceSign(iap.Normal(4, 2.0), positive=True, mode=\"invert\")\n",
    "plot = param.draw_distribution_graph(bins=400)\n",
    "plot_large = ia.imresize_single_image(plot, 2.0)\n",
    "ia.imshow(plot_large)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Note that white vertical lines in the plot seem to be interpolation artifacts in the plotting / image generation.)\n",
    "\n",
    "Using instead `mode=\"reroll\"` leads to the same probability density for `[0, 4]` and `[4, 8]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "param = iap.ForceSign(iap.Normal(4, 2.0), positive=True, mode=\"reroll\")\n",
    "plot = param.draw_distribution_graph(bins=400)\n",
    "plot_large = ia.imresize_single_image(plot, 2.0)\n",
    "ia.imshow(plot_large)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The helpers `Positive()` and `Negative()` are shortcuts for `ForceSign(positive=True)` and `ForceSign(positive=False)`. Example for `Positive`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2 10  5  2 10  2  1  5  1  2  5  1  5  5 10]\n",
      "[ 5 10  5  5  1 10  5 10  5  5  5  2 10 10 10]\n"
     ]
    }
   ],
   "source": [
    "positive_invert = iap.Positive(iap.Choice([-2, -1, 5, 10]), mode=\"invert\")\n",
    "positive_reroll = iap.Positive(iap.Choice([-2, -1, 5, 10]), mode=\"reroll\")\n",
    "print(positive_invert.draw_samples(15))\n",
    "print(positive_reroll.draw_samples(15))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Combining Probability Distributions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`imgaug` allows to combine probability distributions. The example below shows one of these cases, where a the `loc` (i.e. mean) hyperparameter of a gaussian distribution is not a scalar value, but instead a probability distribution of its own, in this case a `Choice`. This produces a gaussian-like distribution with two peaks instead of one. Note here though, that a mean-value is sampled from `Choice` once per call to `Normal.draw_samples()`. Hence, `Normal.draw_samples(1000 * 1000)` will lead to a very different probability distribution than one million calls of `Normal.draw_samples(1)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "param = iap.Normal(iap.Choice([-2, 2]), 1.0)\n",
    "plot = param.draw_distribution_graph()\n",
    "plot_large = ia.imresize_single_image(plot, 2.0)\n",
    "ia.imshow(plot_large)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Choice` can also be used to combine multiple probability distributions. By using it, one can sometimes sample from one distribution and sometimes from another. (This is however quite a bit slower than sampling from each distribution on its own.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "param = iap.Choice([iap.Normal(-1, 1.0), iap.Normal(1, 0.1)])\n",
    "plot = param.draw_distribution_graph()\n",
    "plot_large = ia.imresize_single_image(plot, 2.0)\n",
    "ia.imshow(plot_large)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CoarseSaltAndPepper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combining several stochastic parameters with each other can lead to interesting effects and some augmenters are nothing else than wrappers around stochastic parameters and other basic augmenters (e.g. `AddElementwise` or `ReplaceElementwise`). The example below shows how to implement an augmentation function that applies a coarse form of salt and pepper like noise to an image. It replaces rectangular areas of the image with noise containing very bright and dark pixels. The rectangular mask is sampled from a `Binomial`, which is made coarse using `FromLowerResolution`. The noise is sampled from a `Beta(0.5, 0.5)` distribution, which has most of its probability density around `0.0` and `1.0`. The pixels within the masks are then replaced by the sampled noise using the `ReplaceElementwise` augmenter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1024x512 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def apply_coarse_salt_and_pepper(image, p, size_px):\n",
    "    # mask where to replace\n",
    "    mask = iap.Binomial(p)\n",
    "    \n",
    "    # make the mask coarser\n",
    "    mask_coarse = iap.FromLowerResolution(other_param=mask, size_px=size_px)\n",
    "\n",
    "    # the noise to use as replacements, mostly close to 0.0 and 1.0\n",
    "    replacement = iap.Beta(0.5, 0.5)\n",
    "    \n",
    "    # project noise to uint8 value range\n",
    "    replacement = replacement * 255\n",
    "\n",
    "    # replace masked areas with noise\n",
    "    return iaa.ReplaceElementwise(\n",
    "        mask=mask_coarse,\n",
    "        replacement=replacement\n",
    "    )(image=image)\n",
    "\n",
    "image = ia.quokka_square(size=(128, 128))  # example images\n",
    "image_aug = apply_coarse_salt_and_pepper(image, 0.05, 16)  # apply noise\n",
    "ia.imshow(\n",
    "    ia.imresize_single_image(\n",
    "        np.hstack([image, image_aug]),\n",
    "        4.0\n",
    "    )\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (imgaug37)",
   "language": "python",
   "name": "imgaug37"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}