diff --git a/SLAM/KF_basics_part_1.ipynb b/SLAM/KF_basics_part_1.ipynb new file mode 100644 index 00000000..8ad04e84 --- /dev/null +++ b/SLAM/KF_basics_part_1.ipynb @@ -0,0 +1,793 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# KF Basics - Part I\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### What is the need to describe belief in terms of PDF's?\n", + "This is because robot environments are stochastic. A robot environment may have cows with Tesla by side. That is a robot and it's environment cannot be deterministically modelled(e.g as a function of something like time t.). In the real world sensors are also error prone, and hence there'll be a set of values with a mean and variance that it can take. Hence, we always have to model around some mean and variances associated." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### What is Expectation of a Random Variables?\n", + " Expectation is nothing but an average of the probabilites\n", + " \n", + "$$\\mathbb E[X] = \\sum_{i=1}^n p_ix_i$$\n", + "\n", + "In the continous form,\n", + "\n", + "$$\\mathbb E[X] = \\int_{-\\infty}^\\infty x\\, f(x) \\,dx$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.4000000000000001\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import random\n", + "x=[3,1,2]\n", + "p=[0.1,0.3,0.4]\n", + "E_x=np.sum(np.multiply(x,p))\n", + "print(E_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### What is the advantage of representing the belief as a unimodal as opposed to multimodal?\n", + "Obviously, it makes sense because we can't multiple probabilities to a car moving for two locations. This would be too confusing and the information will not be useful." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Variance, Covariance and Correlation\n", + "\n", + "### Variance\n", + "Variance is the spread of the data. The mean does'nt tell much **about** the data. Therefore the variance tells us about the **story** about the data meaning the spread of the data.\n", + "\n", + "$$\\mathit{VAR}(X) = \\frac{1}{n}\\sum_{i=1}^n (x_i - \\mu)^2$$" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0224618077401504" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=np.random.randn(10)\n", + "np.var(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Covariance\n", + "\n", + "This is for a multivariate distribution. For example, a robot in 2-D space can take values in both x and y. To describe them, a normal distribution with mean in both x and y is needed.\n", + "\n", + "For a multivariate distribution, mean $\\mu can be represented as a matrix, \n", + "\n", + "$$\n", + "\\mu = \\begin{bmatrix}\\mu_1\\\\\\mu_2\\\\ \\vdots \\\\\\mu_n\\end{bmatrix}\n", + "$$\n", + "\n", + "\n", + "Similarly, variance can also be represented.\n", + "\n", + "But an important concept is that in the same way as every variable or dimension has a variation in its values, it is also possible that there will be values on how they **together vary**. This is also a measure of how two datasets are related to each other or **correlation**.\n", + "\n", + "For example, as height increases weight also generally increases. These variables are correlated. They are positively correlated because as one variable gets larger so does the other.\n", + "\n", + "We use a **covariance matrix** to denote covariances of a multivariate normal distribution:\n", + "$$\n", + "\\Sigma = \\begin{bmatrix}\n", + " \\sigma_1^2 & \\sigma_{12} & \\cdots & \\sigma_{1n} \\\\\n", + " \\sigma_{21} &\\sigma_2^2 & \\cdots & \\sigma_{2n} \\\\\n", + " \\vdots & \\vdots & \\ddots & \\vdots \\\\\n", + " \\sigma_{n1} & \\sigma_{n2} & \\cdots & \\sigma_n^2\n", + " \\end{bmatrix}\n", + "$$\n", + "\n", + "**Diagonal** - Variance of each variable associated. \n", + "\n", + "**Off-Diagonal** - covariance between ith and jth variables.\n", + "\n", + "$$\\begin{aligned}VAR(X) = \\sigma_x^2 &= \\frac{1}{n}\\sum_{i=1}^n(X - \\mu)^2\\\\\n", + "COV(X, Y) = \\sigma_{xy} &= \\frac{1}{n}\\sum_{i=1}^n[(X-\\mu_x)(Y-\\mu_y)\\big]\\end{aligned}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.08868895, 0.05064471, 0.08855629],\n", + " [0.05064471, 0.06219243, 0.11555291],\n", + " [0.08855629, 0.11555291, 0.21534324]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=np.random.random((3,3))\n", + "np.cov(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Covariance taking the data as **sample** with $\\frac{1}{N-1}$" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.1571437 , -0.00766623],\n", + " [-0.00766623, 0.13957621]])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_cor=np.random.rand(1,10)\n", + "y_cor=np.random.rand(1,10)\n", + "np.cov(x_cor,y_cor)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Covariance taking the data as **population** with $\\frac{1}{N}$" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.14142933, -0.0068996 ],\n", + " [-0.0068996 , 0.12561859]])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.cov(x_cor,y_cor,bias=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Gaussians \n", + "\n", + "\n", + "\n", + "\n", + "#### Central Limit Theorem\n", + "\n", + "According to this theorem, the average of n samples of random and independant variables tends to follow a normal distribution as we increase the sample size.(Generally, for n>=30)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([ 1., 2., 7., 9., 13., 23., 17., 15., 10., 3.]),\n", + " array([5.28148425, 5.32037699, 5.35926973, 5.39816247, 5.43705521,\n", + " 5.47594795, 5.51484068, 5.55373342, 5.59262616, 5.6315189 ,\n", + " 5.67041164]),\n", + " )" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import random\n", + "a=np.zeros((100,))\n", + "for i in range(100):\n", + " x=[random.uniform(1,10) for _ in range(1000)]\n", + " a[i]=np.sum(x,axis=0)/1000\n", + "plt.hist(a)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Gaussian Distribution\n", + "A Gaussian is a *continuous probability distribution* that is completely described with two parameters, the mean ($\\mu$) and the variance ($\\sigma^2$). It is defined as:\n", + "\n", + "$$ \n", + "f(x, \\mu, \\sigma) = \\frac{1}{\\sigma\\sqrt{2\\pi}} \\exp\\big [{-\\frac{(x-\\mu)^2}{2\\sigma^2} }\\big ]\n", + "$$\n", + "Range is [$-\\inf,\\inf $]\n", + "\n", + "\n", + "This is just a function of mean($\\mu$) and standard deviation ($\\sigma$) and what gives the normal distribution the charecteristic **bell curve**. " + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: scipy.stats.norm.pdf\n", + " import sys\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.mlab as mlab\n", + "import math\n", + "mu = 0\n", + "variance = 5\n", + "sigma = math.sqrt(variance)\n", + "x = np.linspace(mu - 5*sigma, mu + 5*sigma, 100)\n", + "plt.plot(x,mlab.normpdf(x, mu, sigma))\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Why do we need Gaussian distributions?\n", + "Since it becomes really difficult in the real world to deal with multimodal distribution as we cannot put the belief in two seperate location of the robots. This becomes really confusing and in practice impossible to comprehend. \n", + "Gaussian probability distribution allows us to drive the robots using only one mode with peak at the mean with some variance." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gaussian Properties\n", + "\n", + "**Multiplication**\n", + "\n", + "\n", + "For the measurement update in a Bayes Filter, the algorithm tells us to multiply the Prior P(X_t) and measurement P(Z_t|X_t) to calculate the posterior:\n", + "\n", + "$$P(X \\mid Z) = \\frac{P(Z \\mid X)P(X)}{P(Z)}$$\n", + "\n", + "Here for the numerator, $P(Z \\mid X),P(X)$ both are gaussian.\n", + "\n", + "$N(\\bar\\mu, \\bar\\sigma^1)$ and $N(\\bar\\mu, \\bar\\sigma^2)$ are their mean and variances.\n", + "\n", + "New mean is \n", + "\n", + "$$\\mu_\\mathtt{new} = \\frac{\\sigma_z^2\\bar\\mu + \\bar\\sigma^2z}{\\bar\\sigma^2+\\sigma_z^2}$$\n", + "New variance is\n", + "$$\n", + "\\sigma_\\mathtt{new} = \\frac{\\sigma_z^2\\bar\\sigma^2}{\\bar\\sigma^2+\\sigma_z^2}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New mean is at: 5.0\n", + "New variance is: 1.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: scipy.stats.norm.pdf\n", + " import sys\n", + "/usr/local/lib/python3.6/site-packages/ipykernel_launcher.py:13: MatplotlibDeprecationWarning: scipy.stats.norm.pdf\n", + " del sys.path[0]\n", + "/usr/local/lib/python3.6/site-packages/ipykernel_launcher.py:22: MatplotlibDeprecationWarning: scipy.stats.norm.pdf\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.mlab as mlab\n", + "import math\n", + "mu1 = 0\n", + "variance1 = 2\n", + "sigma = math.sqrt(variance1)\n", + "x1 = np.linspace(mu1 - 3*sigma, mu1 + 3*sigma, 100)\n", + "plt.plot(x1,mlab.normpdf(x1, mu1, sigma),label='prior')\n", + "\n", + "mu2 = 10\n", + "variance2 = 2\n", + "sigma = math.sqrt(variance2)\n", + "x2 = np.linspace(mu2 - 3*sigma, mu2 + 3*sigma, 100)\n", + "plt.plot(x2,mlab.normpdf(x2, mu2, sigma),\"g-\",label='measurement')\n", + "\n", + "\n", + "mu_new=(mu1*variance2+mu2*variance1)/(variance1+variance2)\n", + "print(\"New mean is at: \",mu_new)\n", + "var_new=(variance1*variance2)/(variance1+variance2)\n", + "print(\"New variance is: \",var_new)\n", + "sigma = math.sqrt(var_new)\n", + "x3 = np.linspace(mu_new - 3*sigma, mu_new + 3*sigma, 100)\n", + "plt.plot(x3,mlab.normpdf(x3, mu_new, var_new),label=\"posterior\")\n", + "plt.legend(loc='upper left')\n", + "plt.xlim(-10,20)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Addition**\n", + "\n", + "The motion step involves a case of adding up probability (Since it has to abide the Law of Total Probability). This means their beliefs are to be added and hence two gaussians. They are simply arithmetic additions of the two.\n", + "\n", + "$$\\begin{gathered}\\mu_x = \\mu_p + \\mu_z \\\\\n", + "\\sigma_x^2 = \\sigma_z^2+\\sigma_p^2\\, \\square\\end{gathered}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New mean is at: 15\n", + "New variance is: 2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/site-packages/ipykernel_launcher.py:7: MatplotlibDeprecationWarning: scipy.stats.norm.pdf\n", + " import sys\n", + "/usr/local/lib/python3.6/site-packages/ipykernel_launcher.py:13: MatplotlibDeprecationWarning: scipy.stats.norm.pdf\n", + " del sys.path[0]\n", + "/usr/local/lib/python3.6/site-packages/ipykernel_launcher.py:22: MatplotlibDeprecationWarning: scipy.stats.norm.pdf\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.mlab as mlab\n", + "import math\n", + "mu1 = 5\n", + "variance1 = 1\n", + "sigma = math.sqrt(variance1)\n", + "x1 = np.linspace(mu1 - 3*sigma, mu1 + 3*sigma, 100)\n", + "plt.plot(x1,mlab.normpdf(x1, mu1, sigma),label='prior')\n", + "\n", + "mu2 = 10\n", + "variance2 = 1\n", + "sigma = math.sqrt(variance2)\n", + "x2 = np.linspace(mu2 - 3*sigma, mu2 + 3*sigma, 100)\n", + "plt.plot(x2,mlab.normpdf(x2, mu2, sigma),\"g-\",label='measurement')\n", + "\n", + "\n", + "mu_new=mu1+mu2\n", + "print(\"New mean is at: \",mu_new)\n", + "var_new=(variance1+variance2)\n", + "print(\"New variance is: \",var_new)\n", + "sigma = math.sqrt(var_new)\n", + "x3 = np.linspace(mu_new - 3*sigma, mu_new + 3*sigma, 100)\n", + "plt.plot(x3,mlab.normpdf(x3, mu_new, var_new),label=\"posterior\")\n", + "plt.legend(loc='upper left')\n", + "plt.xlim(-10,20)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Example from:\n", + "#https://scipython.com/blog/visualizing-the-bivariate-gaussian-distribution/\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import cm\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "\n", + "# Our 2-dimensional distribution will be over variables X and Y\n", + "N = 60\n", + "X = np.linspace(-3, 3, N)\n", + "Y = np.linspace(-3, 4, N)\n", + "X, Y = np.meshgrid(X, Y)\n", + "\n", + "# Mean vector and covariance matrix\n", + "mu = np.array([0., 1.])\n", + "Sigma = np.array([[ 1. , -0.5], [-0.5, 1.5]])\n", + "\n", + "# Pack X and Y into a single 3-dimensional array\n", + "pos = np.empty(X.shape + (2,))\n", + "pos[:, :, 0] = X\n", + "pos[:, :, 1] = Y\n", + "\n", + "def multivariate_gaussian(pos, mu, Sigma):\n", + " \"\"\"Return the multivariate Gaussian distribution on array pos.\n", + "\n", + " pos is an array constructed by packing the meshed arrays of variables\n", + " x_1, x_2, x_3, ..., x_k into its _last_ dimension.\n", + "\n", + " \"\"\"\n", + "\n", + " n = mu.shape[0]\n", + " Sigma_det = np.linalg.det(Sigma)\n", + " Sigma_inv = np.linalg.inv(Sigma)\n", + " N = np.sqrt((2*np.pi)**n * Sigma_det)\n", + " # This einsum call calculates (x-mu)T.Sigma-1.(x-mu) in a vectorized\n", + " # way across all the input variables.\n", + " fac = np.einsum('...k,kl,...l->...', pos-mu, Sigma_inv, pos-mu)\n", + "\n", + " return np.exp(-fac / 2) / N\n", + "\n", + "# The distribution on the variables X, Y packed into pos.\n", + "Z = multivariate_gaussian(pos, mu, Sigma)\n", + "\n", + "# Create a surface plot and projected filled contour plot under it.\n", + "fig = plt.figure()\n", + "ax = fig.gca(projection='3d')\n", + "ax.plot_surface(X, Y, Z, rstride=3, cstride=3, linewidth=1, antialiased=True,\n", + " cmap=cm.viridis)\n", + "\n", + "cset = ax.contourf(X, Y, Z, zdir='z', offset=-0.15, cmap=cm.viridis)\n", + "\n", + "# Adjust the limits, ticks and view angle\n", + "ax.set_zlim(-0.15,0.2)\n", + "ax.set_zticks(np.linspace(0,0.2,5))\n", + "ax.view_init(27, -21)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is a 3D projection of the gaussians involved with the lower surface showing the 2D projection of the 3D projection above. The innermost ellipse represents the highest peak, that is the maximum probability for a given (X,Y) value.\n", + "\n", + "\n", + "\n", + "\n", + "##### numpy einsum examples" + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0 1 2 3 4]\n", + " [ 5 6 7 8 9]\n", + " [10 11 12 13 14]\n", + " [15 16 17 18 19]\n", + " [20 21 22 23 24]]\n", + "[0 1 2 3 4]\n", + "[[0 1 2]\n", + " [3 4 5]]\n" + ] + } + ], + "source": [ + "a = np.arange(25).reshape(5,5)\n", + "b = np.arange(5)\n", + "c = np.arange(6).reshape(2,3)\n", + "print(a)\n", + "print(b)\n", + "print(c)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 30, 80, 130, 180, 230])" + ] + }, + "execution_count": 204, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#this is the diagonal sum, i repeated means the diagonal\n", + "np.einsum('ij', a)\n", + "#this takes the output ii which is the diagonal and outputs to a\n", + "np.einsum('ii->i',a)\n", + "#this takes in the array A represented by their axes 'ij' and B by its only axes'j' \n", + "#and multiples them element wise\n", + "np.einsum('ij,j',a, b)" + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 22, 76])" + ] + }, + "execution_count": 199, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A = np.arange(3).reshape(3,1)\n", + "B = np.array([[ 0, 1, 2, 3],\n", + " [ 4, 5, 6, 7],\n", + " [ 8, 9, 10, 11]])\n", + "C=np.multiply(A,B)\n", + "np.sum(C,axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 197, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 22, 76])" + ] + }, + "execution_count": 197, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "D = np.array([0,1,2])\n", + "E = np.array([[ 0, 1, 2, 3],\n", + " [ 4, 5, 6, 7],\n", + " [ 8, 9, 10, 11]])\n", + "\n", + "np.einsum('i,ij->i',D,E)" + ] + }, + { + "cell_type": "code", + "execution_count": 238, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 238, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy.stats import multivariate_normal\n", + "x, y = np.mgrid[-5:5:.1, -5:5:.1]\n", + "pos = np.empty(x.shape + (2,))\n", + "pos[:, :, 0] = x; pos[:, :, 1] = y\n", + "rv = multivariate_normal([0.5, -0.2], [[2.0, 0.9], [0.9, 0.5]])\n", + "plt.contourf(x, y, rv.pdf(pos))\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### References:\n", + "\n", + "1. Roger Labbe's [repo](https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python) on Kalman Filters. (Majority of the examples in the notes are from this)\n", + "\n", + "\n", + "\n", + "2. Probabilistic Robotics by Sebastian Thrun, Wolfram Burgard and Dieter Fox, MIT Press.\n", + "\n", + "\n", + "\n", + "3. Scipy [Documentation](https://scipython.com/blog/visualizing-the-bivariate-gaussian-distribution/)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}