From ff9c20d7c1d0e40222fae0d1701860dc742851d0 Mon Sep 17 00:00:00 2001 From: Roger Labbe Date: Mon, 28 Apr 2014 16:14:43 -0500 Subject: [PATCH] initial commit --- Untitled0.ipynb | 114 ++++++++++++ gauss.py | 117 +++++++++++++ gaussian.py | 83 +++++++++ histogram.py | 57 ++++++ kalman filter 1D.ipynb | 383 +++++++++++++++++++++++++++++++++++++++++ 5 files changed, 754 insertions(+) create mode 100644 Untitled0.ipynb create mode 100644 gauss.py create mode 100644 gaussian.py create mode 100644 histogram.py create mode 100644 kalman filter 1D.ipynb diff --git a/Untitled0.ipynb b/Untitled0.ipynb new file mode 100644 index 0000000..ef5e97a --- /dev/null +++ b/Untitled0.ipynb @@ -0,0 +1,114 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "code", + "collapsed": false, + "input": [ + "def to_array(x):\n", + " try:\n", + " x.shape\n", + " try:\n", + " if type(x) != numpy.ndarray:\n", + " x=asarray(x)[0]\n", + " return x\n", + " except:\n", + " pass\n", + "\n", + " except:\n", + " return array(mat(x)).reshape(1)\n", + "\n", + "def to_cov(x,n):\n", + " try:\n", + " x.shape\n", + " return x\n", + " except:\n", + " return eye(n) * x\n", + " \n", + "def multivariate_gaussian (x, mu, cov):\n", + " \"\"\" This is designed to work the same as scipy.stats.multivariate_normal\n", + " which is available before version 0.14. You may either pass in a \n", + " multivariate set of data:\n", + " multivariate_gaussian (array([1,1]), array([3,4]), eye(2)*1.4)\n", + " or unidimensional data:\n", + " multivariate_gaussian(1, 3, 1.4)\n", + " \n", + " In the multivariate case if cov is a scalar it is interpreted as eye(n)*cov\n", + " \"\"\"\n", + " \n", + " # force all to numpy.array type\n", + " x = to_array(x)\n", + " mu = to_array(mu)\n", + " n = mu.size\n", + " cov = to_cov (cov, n)\n", + "\n", + " det = numpy.sqrt(numpy.prod(numpy.diag(cov)))\n", + " frac = (2*numpy.pi)**(-n/2.0) * (1.0/det)\n", + " fprime = x - mu\n", + " fprime **= 2\n", + " m = frac * numpy.exp(-0.5*numpy.dot(fprime, 1/numpy.diag(cov)))\n", + " return m\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 24 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print mvg (array([1,1]), array([1,1]), eye(2))\n", + "print mvg (mat([1,1]), mat([1,1]), eye(2))\n", + "print mvg (2,3,1)\n", + "\n", + "\n", + "\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "0.159154943092\n", + "0.159154943092\n", + "0.241970724519\n" + ] + } + ], + "prompt_number": 30 + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print numpy.array(3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "3\n" + ] + } + ], + "prompt_number": 17 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/gauss.py b/gauss.py new file mode 100644 index 0000000..9579ccb --- /dev/null +++ b/gauss.py @@ -0,0 +1,117 @@ +# -*- coding: utf-8 -*- +""" +Created on Tue Apr 22 11:38:49 2014 + +@author: rlabbe +""" +from __future__ import division, print_function +import math +import matplotlib.pyplot as plt +import numpy.random as random + + +class gaussian(object): + def __init__ (self,m,s): + self.mu = float(m) + self.sigma = float(s) + + def __add__ (a,b): + return gaussian (a.mu + b.mu, a.sigma + b.sigma) + + def __mul__ (a,b): + m = (a.sigma*b.mu + b.sigma*a.mu) / (a.sigma + b.sigma) + s = 1. / (1./a.sigma + 1./b.sigma) + return gaussian (m,s) + + def __call__(self,x): + return math.exp (-0.5 * (x-self.mu)**2 / self.sigma) / \ + math.sqrt(2.*math.pi*self.sigma) + + def __str__(self): + return "(%f, %f)" %(self.mu, self.sigma) + + def __getitem__ (self,index): + """ maybe silly, allows you to access obect as a tuple: + a = gaussian(3,4) + print (tuple(a)) + """ + if index == 0: return self.mu + elif index == 1: return self.sigma + else: raise StopIteration + +class KF1D(object): + def __init__ (self, pos, sigma): + self.estimate = gaussian(pos,sigma) + + def update(self, Z,var): + self.estimate = self.estimate * gaussian (Z,var) + + def predict(self, U, var): + self.estimate = self.estimate + gaussian (U,var) + + +measurements = [x+5 for x in range(100)] + + + +def fixed_error_kf(measurement_error, noise_factor = 1.0): + motion_sig = 2. + mu = 0 + sig = 1000 + + f = KF1D (mu,sig) + + ys = [] + errs = [] + xs = [] + + for i in range(len(measurements)): + r = random.randn() * noise_factor + m = measurements[i] + r + f.update (m, measurement_error) + + xs.append(m) + ys.append(f.estimate.mu) + errs.append (f.estimate.sigma) + + f.predict (1.0, motion_sig) + + plt.clf() + + plt.plot (measurements, 'r') + plt.plot (xs,'g') + plt.errorbar (x=range(len(ys)), color='b', y=ys, yerr=errs) + plt.show() + +def varying_error_kf(noise_factor=1.0): + motion_sig = 2. + mu = 0 + sig = 1000 + + + f = KF1D (mu,sig) + ys = [] + us = [] + errs = [] + xs = [] + + for i in range(len(measurements)): + r = random.randn() * noise_factor + m = measurements[i] + r + print (r) + f.update (m, abs(r*10)) + xs.append(m) + #print ("measure:" + str(f.estimate)) + ys.append(f.estimate.mu) + errs.append (f.estimate.sigma) + + f.predict (1.0, motion_sig) + #print ("predict:" + str(f.estimate)) + + plt.clf() + plt.plot (measurements, 'r') + plt.plot (xs,'g') + plt.errorbar (x=range(len(ys)), color='b', y=ys, yerr=errs) + plt.show() + +varying_error_kf( noise_factor=100) diff --git a/gaussian.py b/gaussian.py new file mode 100644 index 0000000..60ae39f --- /dev/null +++ b/gaussian.py @@ -0,0 +1,83 @@ +import numpy as np +import math + + +def _to_array(x): + """ returns any of a scalar, matrix, or array as a 1D numpy array + Example: + _to_array(3) == array([3]) + """ + try: + x.shape + if type(x) != np.ndarray: + x = np.asarray(x)[0] + return x + except: + return np.array(np.mat(x)).reshape(1) + +def _to_cov(x,n): + """ If x is a scalar, returns a covariance matrix generated from it + as the identity matrix multiplied by x. The dimension will be nxn. + If x is already a numpy array then it is returned unchanged. + """ + try: + x.shape + if type(x) != np.ndarray: + x = np.asarray(x)[0] + return x + except: + return np.eye(n) * x + +_two_pi = 2*math.pi + +def gaussian (x, mean, var): + """returns normal distribution for x given a gaussian with the specified + mean and variance. All must be scalars + """ + return math.exp((-0.5*(x-mean)**2)/var) / math.sqrt(_two_pi*var) + + +def multivariate_gaussian (x, mu, cov): + """ This is designed to work the same as scipy.stats.multivariate_normal + which is not available before version 0.14. You may either pass in a + multivariate set of data: + multivariate_gaussian (array([1,1]), array([3,4]), eye(2)*1.4) + multivariate_gaussian (array([1,1,1]), array([3,4,5]), 1.4) + or unidimensional data: + multivariate_gaussian(1, 3, 1.4) + + In the multivariate case if cov is a scalar it is interpreted as eye(n)*cov + + The function gaussian() implements the 1D (univariate)case, and is much + faster than this function. + """ + + # force all to numpy.array type + x = _to_array(x) + mu = _to_array(mu) + n = mu.size + cov = _to_cov (cov, n) + + det = np.sqrt(np.prod(np.diag(cov))) + frac = _two_pi**(-n/2.) * (1./det) + fprime = (x - mu)**2 + return frac * np.exp(-0.5*np.dot(fprime, 1./np.diag(cov))) + + +if __name__ == '__main__': + from scipy.stats import norm + + # test conversion of scalar to covariance matrix + x = multivariate_gaussian(np.array([1,1]), np.array([3,4]), np.eye(2)*1.4) + x2 = multivariate_gaussian(np.array([1,1]), np.array([3,4]), 1.4) + assert x == x2 + + # test univarate case + rv = norm (loc = 1., scale = np.sqrt(2.3)) + x2 = multivariate_gaussian (1.2, 1., 2.3) + x3 = gaussian (1.2, 1., 2.3) + + assert rv.pdf(1.2) == x2 + assert abs(x2- x3) < 0.00000001 + print "all tests passed" + diff --git a/histogram.py b/histogram.py new file mode 100644 index 0000000..2f7f0b6 --- /dev/null +++ b/histogram.py @@ -0,0 +1,57 @@ +# -*- coding: utf-8 -*- +""" +Created on Tue Apr 22 10:43:38 2014 + +@author: rlabbe +""" + +p = [.2, .2, .2, .2, .2] +world = ['green', 'red', 'red', 'green', 'green'] +measurements = ['red', 'green'] + +pHit = 0.6 +pMiss = 0.2 + +pOvershoot = 0.1 +pUndershoot = 0.1 +pExact = 0.8 + +def normalize (p): + s = sum(p) + for i in range (len(p)): + p[i] = p[i] / s + +def sense(p, Z): + q= [] + for i in range (len(p)): + hit = (world[i] ==Z) + q.append(p[i] * (pHit*hit + pMiss*(1-hit))) + normalize(q) + return q + + +def move(p, U): + q = [] + for i in range(len(p)): + pexact = p[(i-U) % len(p)] * pExact + pover = p[(i-U-1) % len(p)] * pOvershoot + punder = p[(i-U+1) % len(p)] * pUndershoot + q.append (pexact + pover + punder) + + normalize(q) + return q + +if __name__ == "__main__": + + p = sense(p, 'red') + print p + pause() + for z in measurements: + p = sense (p, z) + p = move (p, 1) + print p + + + + + diff --git a/kalman filter 1D.ipynb b/kalman filter 1D.ipynb new file mode 100644 index 0000000..6d6ebc1 --- /dev/null +++ b/kalman filter 1D.ipynb @@ -0,0 +1,383 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Introduction to Tracking" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us begin with a simple problem. We have a dog friendly workspace, and so people bring their dogs to work. However, occasionally the dogs wander out of your office and down the halls. We want to be able to track them. So during a hackathon somebody created a little sonar sensor to attach to the dog's collar. It emits a signal, listens for the echo, and based on how quickly an echo comes back we can tell whether the dog is in front of an open doorway or not. It also senses when the dog walks, and reports in which direction the dog has moved. It connects to our network via wifi and sends an update once a second.\n", + "\n", + "I want to track my dog Simon, so I attach the device to his collar and then fire up Python, ready to try to write code to track him through the building. At first blush this may appear impossible. If I start listening to the sensor of Simon's collar I might read 'door', 'hall', 'hall', and so on. How can I use that information to determine where Simon is?\n", + "\n", + "To keep the problem small, we will assume that there are only 10 positions in a single hallway to consider. The first position corresponds to the far left end of the corridor, and the last position to the far right. \n", + "\n", + "When I begin listening to the sensor I have no reason to believe that Simon is at any particular position in the hallway. He is equally likely to be in any position. The probability that he is in each position is therefore $1/10$ \n", + "\n", + "Let us represent our belief of his position at any time in a numpy array." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "pos = array([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's create a map of the hallway in another list. Suppose rehere are first two doors close together, and then another door quite a bit further down the hallway. We will use 1 to denote a door, and 0 to denote a wall:" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "hallway = array([1, 1, 0, 0, 0, 0, 0, 0, 1, 0])" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So I start listening to Simon's transmissions on the network, and the first data I get from the sesnor is \"door\". From this I conclude that he is in front of a door, but which one? I have no idea. I have no reason to believe is in front of the first, second, or third door. But what I can do is assign a probability to each door. All doors are equally likely, so I assign a probability of 1/3 to each door. " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "pos = array([0.333, 0.333, 0., 0., 0., 0., 0., 0., 0.333, 0.])\n", + "\n", + "ax = plt.figure().gca()\n", + "x = np.arange(10)\n", + "ax.bar(x, pos)\n", + "plt.xticks(x+0.5, x)\n", + "plt.show()\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEACAYAAAC57G0KAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n", + "text": [ + "" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We call this a multimodal distribution because we have multiple beliefs about the position of our dog. Of course we are not saying that we think he is simultaneously in three different locations, merely that so far we have narrowed down our knowledge in his position to these locations. \n", + "\n", + "I hand coded the pos array in the code above. How would we implement this in code? Well, hallway represents each door as a 1, and wall as 0, so we will multiply the hallway variable by the percentage, like so;" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "pos = hallway * 0.3\n", + "print 'pos =', pos" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "pos = [ 0.3 0.3 0. 0. 0. 0. 0. 0. 0.3 0. ]\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 4, + "metadata": {}, + "source": [ + "Extracting Information from Multiple Sensor Readings" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's put Python aside and think about the problem a bit. Suppose we were to read the following from Simon's sensor:\n", + "\n", + " * door\n", + " * move right\n", + " * door\n", + " \n", + "\n", + "Can we deduce where Simon is at the end of that sequence? Of course! There is only one place where you can be in front of a door, move once to the right, and be in front of another door, and that is at the left end of the hallway. Therefore we can confidently state that Simon is in front of the second doorway. If this is not clear, suppose Simon had started at the second or third door. After moving to the right, his sensor would have returned 'wall'. Therefore the only possibility is that he is now in front of the second door. We denote this in Python with:" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "pos = array([0,1,0,0,0,0,0,0,0,0])\n", + "print pos" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[0 1 0 0 0 0 0 0 0 0]\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Obviously I carefully constructed the hallway layout and sensor readings to give us an exact answer quickly. Real problems will not be so clear cut. But this should trigger your intuition - the first sensor reading only gave us very low probabilities (0.333) for Simon's location, but after a position update and another sensor reading we knew much more about where he is. You might suspect, correctly, that if you had a very long hallway with a large number of doors that after several sensor readings and positions updates we would either be able to know where Simon was, or have the possibilities narrowed down to a small number of possibilities. For example, suppose we had a long sequence of \"door, right, door, right, wall, right, wall, right, door, right, door, right, wall, right, wall, right, wall, right, wall, right, door\". Simon could only be located where we had a sequence of [1,1,0,0,1,1,0,0,0,0,1] in the hallway. There might be only one match for that, or at most a few. Either way we will be far more certain about his position then when we started.\n", + "\n", + "We could work through the code to implement this solution, but before we do, let us consider a real world complication." + ] + }, + { + "cell_type": "heading", + "level": 4, + "metadata": {}, + "source": [ + "Noisy Sensors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Unfortunately I have yet to come across a perfect sensor. Perhaps the sensor would not detect a door if Simon sat in front of it while scratching himself, or it might report there is a door if he is facing towards the wall, not down the hallway. So in practice when I get a report 'door' I cannot assign 1/3 as the probability for each door. I have to assign something less than 1/3 to each door, and then assign a small probability to each blank wall position. At this point it doesn't matter exactly what numbers we assign; let us say that the probably of 'door' being correct is 0.6, and the probability of being incorrect is 0.2. How would we do this?\n", + "\n", + "Well, the probability that he is in front of a door is $1 / 3 * 0.6$. That is, there are 3 doors, the chance of being right is 0.6, so the result is 0.2. The probability that he is actually in front of a blank wall is 1/4 * 0.2, or 0.05. Our belief vector now looks like:" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "pos = array([.2, .2, .05, .05, .05, .05, .05, .05, .2, .05])" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 14 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As before, instead of manually creating the pos array, we will create it programmatically\n" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "q = []\n", + "\n", + "# figure out probability of being in front of a door if sensor is perfect\n", + "\n", + "\n", + "# adjust probability by the accuracy of the sensor\n", + "for i in range(len(hallway)):\n", + " if hallway[i] == 1:\n", + " q.append (pos[i] * 0.6)\n", + " else:\n", + " q.append (pos[i] * 0.2)\n", + " \n", + "def normalize (p):\n", + " s = sum(p)\n", + " for i in range (len(p)):\n", + " p[i] = p[i] / s\n", + "pos = array(q)\n", + "normalize(pos)\n", + "print pos" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[ 0.32628399 0.32628399 0.00302115 0.00302115 0.00302115 0.00302115\n", + " 0.00302115 0.00302115 0.32628399 0.00302115]\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Gaussian Probabilities" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So let us explore how gaussians work. A gaussian is a probability distribution that is completely described with two parameters, the mean and the variance. It is defined as:\n", + "$$ \n", + "f(x, \\mu, \\sigma) = \\frac{1}{\\sigma\\sqrt{2\\pi}} e^{-0.5*{(x-\\mu)^2}/\\sigma^2 }\n", + "$$\n", + "\n", + "where $\\mu$ is the mean and $\\sigma^2$ is the variance (we will define these in a moment).\n", + "Let us plot that with Python. First, we will define a function that computes the gaussian for any x. " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "def gaussian (x, mu, sigma):\n", + " ''' compute the gaussian with the specified mean and sigma'''\n", + " return math.exp (-0.5 * (x-mu)**2 / sigma) / math.sqrt(2.*math.pi*sigma)" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": 1 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we will plot a gaussian centered around 5, with a variance of 1." + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "xs = np.arange(0,10,0.1)\n", + "plt.plot (xs,[gaussian(x, 5, 1) for x in xs])\n", + "plt.axvline (5) \n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAXsAAAEACAYAAABS29YJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text": [ + "" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we expected the curve is centered around 5. We can see why this is by looking at the equation for the gaussian. When x=5, x-\\mu is 0, and thus e^0 is 1. any other value for x will result in a smaller value for exp function.\n", + "\n", + "The width of the curve is defined by the variance. If the variance is large than the curve will be wide, and if the variance is small the curve will be narrow.\n", + "\n", + "Also, since this is a probability distribution it is required that the area under the curve always equals one. This should be intuitively clear - the area under the curve represents all possible occurances, which must sum to one.\n", + "\n", + "This leads to an important insight. If the variance is small the curve will be narrow. To keep the area == 1, the curve must also be tall. On the other hand if the variance is large the curve will be wide, and thus it will also have to be short to make the area == 1.\n", + "\n", + "Let us look at that:" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "plt.plot (xs,[g(x, 5, .2) for x in xs],'b')\n", + "plt.plot (xs,[g(x, 5, 1) for x in xs],'g')\n", + "plt.plot (xs,[g(x, 5, 5) for x in xs],'r')\n", + "\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEACAYAAABMEua6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nEQp1QgixIv8P2EKbdYjj/hwAAAAASUVORK5CYII=\n", + "text": [ + "" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So what is this telling us? The blue gaussian is very narrow. It is saying that we believe x=5, and that we are very sure about that. In contrast, the red gaussian also believes that x=5, but we are much less sure about that. Our believe that x=5 is lower, and our belief about the likely possible values for x is spread out - we think it is quite likely that x=2 or x=8, for example. The blue gaussian has almost completely eliminated 2 or 8 as possible value - their probably is almost 0.0.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$e$$\n", + "\n" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [], + "language": "python", + "metadata": {}, + "outputs": [] + } + ], + "metadata": {} + } + ] +} \ No newline at end of file