diff --git a/Autocorrelation.ipynb b/Autocorrelation.ipynb new file mode 100644 index 0000000..195ab6b --- /dev/null +++ b/Autocorrelation.ipynb @@ -0,0 +1,258 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Title: Fuzzy sequence matching with cross-correlation\n", + "\n", + "## Cross-correlation\n", + "\n", + "I am going to generate a \"random file\" - an array with values ranging between -1 and 1, and then randomly choose a \"random slice\" - a subarray portion from the \"random file\". I'm then going to randomly mutate some of the values in teh subarray, and see if I can still find where in the \"random file\" the \"random slice\" came from." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import random\n", + "import numpy as np\n", + "\n", + "FILE_SIZE = 100000\n", + "SLICE_SIZE = 100\n", + "\n", + "random_file = np.asarray([random.uniform(-1,1) for i in range(FILE_SIZE)])\n", + "random_slice_index = random.randint(0, FILE_SIZE-SLICE_SIZE)\n", + "random_slice = random_file[random_slice_index:random_slice_index+SLICE_SIZE]\n", + "\n", + "# Randomly change the sample by about 50% - simulating a 50% noise\n", + "random_slice_mutated = np.asarray([i + random.uniform(-0.5,0.5) for i in random_slice])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So now, we are going to try to find where in `random_file` the `random_slice_mutated` came from. We know it should be `random_slice_index`.\n", + "\n", + "### First, let's write our own cross-correlation function to find it." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Coding our own cross-correlation algorithm\n", + "\n", + "def find_sample_index(container, sample):\n", + " best_match_index = 0\n", + " largest_dot_product = 0\n", + " sample_size = len(sample)\n", + " for index in range(len(container) - sample_size):\n", + " dot = np.dot(container[index:index+sample_size], sample)\n", + " if dot > largest_dot_product:\n", + " best_match_index = index\n", + " largest_dot_product = dot\n", + " return (best_match_index, largest_dot_product)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(14108, 33.238798044766)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "find_sample_index(random_file, random_slice_mutated)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Actual index (should match): 14108\n" + ] + } + ], + "source": [ + "print(\"Actual index (should match):\", random_slice_index)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now, let's use the `scipy.signal.correlate()` function instead of our own one.\n", + "\n", + "Note that the numpy implementation returns a vector of all of the correlation values, not just the largest one, so to find the largest index, we need to find the largest value." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "14108" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import scipy.signal\n", + "result = scipy.signal.correlate(random_file, random_slice)\n", + "max_correlation_index = np.argmax(result) - (SLICE_SIZE-1)\n", + "max_correlation_index" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cross-correlation algorithm" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 3, 8, 14, 20, 26, 14, 5])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = np.array([1,2,3,4,5])\n", + "b = np.array([1,2,3])\n", + "scipy.signal.correlate(a,b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For vectors:\n", + "\n", + "A=\n", + "\n", + "\n", + "
12345
\n", + "\n", + "B=\n", + "\n", + "\n", + "
123
\n", + "\n", + "The cross-correlate algorithm zero-pads each vector as such (where the blank cells represent 0):\n", + "\n", + "#### Step 1\n", + "\n", + "\n", + "\n", + "
12345
123
\n", + "\n", + " 0*1 + 0*2 + 1*3 + 2*0 + 3*0 + 4*0 + 5*0 = 3\n", + "\n", + "#### Step 2\n", + "\n", + "\n", + "\n", + "
12345
123
\n", + "\n", + " 0*1 + 1*2 + 2*3 + 3*0 + 4*0 + 5*0 = 8\n", + "\n", + "#### Step 3\n", + "\n", + "\n", + "\n", + "
12345
123
\n", + "\n", + " 1*1 + 2*2 + 3*3 + 4*0 + 5*0 = 14\n", + "\n", + "## ...\n", + "\n", + "#### Last step\n", + "\n", + "\n", + "\n", + "
12345
123
\n", + "\n", + "So each step consists of doing the appropriate zero-padding and taking the dot product of the 2 vectors, and then moving to the right one spot." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/ExpectedValue.ipynb b/ExpectedValue.ipynb new file mode 100644 index 0000000..6bfe5ff --- /dev/null +++ b/ExpectedValue.ipynb @@ -0,0 +1,191 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "values = [1]*10 + [5]*1000 + [10000]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Median" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "median = values[len(values)//2]\n", + "median" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mode" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Counter({1: 10, 5: 1000, 10000: 1})" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import collections\n", + "counts = collections.Counter(values)\n", + "counts" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mode = counts.most_common()[0][0]\n", + "mode" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mean/average" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "14.846686449060336" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "average = sum(values) / len(values)\n", + "average" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Expected Value\n", + "\n", + "The Expected Value is the same as the Mean, but I'm calculating it in a probabilistic way to show they are the same" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "14.846686449060336" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "expected_value = 1 * (10/len(values)) + 5 * (1000/len(values)) + 10000 * (1/len(values))\n", + "expected_value" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/PoissonDistribution.ipynb b/PoissonDistribution.ipynb new file mode 100644 index 0000000..0af3c51 --- /dev/null +++ b/PoissonDistribution.ipynb @@ -0,0 +1,253 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Poisson Distribution\n", + "\n", + "probability density function: \n", + "\n", + "\\begin{equation}\n", + "\\frac{\\lambda^k e^{-\\lambda}}{k!}\n", + "\\end{equation}\n", + "\n", + "mean:\n", + "\\begin{equation}\n", + "\\lambda\n", + "\\end{equation}\n", + "\n", + "variance:\n", + "\\begin{equation}\n", + "\\lambda\n", + "\\end{equation}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import math\n", + "import numpy as np\n", + "import scipy.stats as stats\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discrete pmf" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEACAYAAABfxaZOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ndGdWAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "a = range(16)\n", + "lambda1 = 1.5\n", + "\n", + "plt.bar(a, stats.poisson.pmf(a, lambda1), color=\"#348ABD\",\n", + " label=\"$\\lambda = %.1f$\" % lambda1, alpha=0.60,\n", + " edgecolor=\"#348ABD\", lw=\"3\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Continuous pdf" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEACAYAAABI5zaHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nu4hIAVK4i4gUIIW7iEgBUriLiBSg/w8ReQZ4gAYWLgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "a = np.linspace(0, 16, 100)\n", + "lambda1 = 0.5\n", + "plt.plot(a, stats.expon.pdf(a, scale=1/lambda1), lw=3,\n", + " color=\"#348ABD\", label=\"$\\lambda = %.1f$\" % lambda1)\n", + "plt.fill_between(a, stats.expon.pdf(a, scale=1/lambda1), color=\"#348ABD\", alpha=.33)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def poisson(lamb, k):\n", + " return (lamb**k * math.e**(-1*k)) / math.factorial(k)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.02800522595692347" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "poisson(1.5, 3)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXEAAAEDCAYAAADDbTRuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAEkVJREFUeJzt3X2wXHV9x/H3N0QSIiQ8KWAiyIOQDiNP0pSpjFy1NRda\njbVMBWZ8oJZhpk11pp2K4nQIHY3oqOMoRQlm6GhL4wO1YitJqrJSrQKWJIDeK49CbgwISgioSZP4\n7R/nJG4292HvuRtyfzfv18xOzvmd3373e/fu/ezZc3Y3kZlIkso0bV83IElqzhCXpIIZ4pJUMENc\nkgpmiEtSwQxxSSrYmCEeEcsj4omIuGeUOZ+MiAciYm1EnNHbFiVJI+lmT/xGYOFIGyPifODEzHw5\ncDnwmR71Jkkaw5ghnpnfAZ4eZcoi4HP13DuAORFxVG/akySNphfHxOcC69vWN9RjkqS9zBObklSw\n6T2osQF4adv6vHpsDxHhF7VIUgOZGcONd7snHvVlOLcAbwOIiHOATZn5xCiN7Lp8cOUAi7+4hgs/\n+709Lr/zhnfuMbb4i2v44MqB3WqM53LVVVc1vu7zVbOEHq1pTWs+vzVHM+aeeETcBPQBR0TEY8BV\nwIFVHueyzPx6RFwQEQ8CvwQuHavmcM6cd+hu67+YPXO3sTVDm5qUlaQpbcwQz8xLupizuDftSJLG\nY9Ke2Dz+tAU9r9nX1zfpa5bQozWtac3JUzPGOt7SSxGR7be3dNUgGzdv4fHNW/Y4nNJpzdAmjp49\nk2Nmz+TKhfP3dquSNGlEBDnBE5uSpEnIEJekghniklQwQ1ySCmaIS1LBDHFJKpghLkkFM8QlqWCG\nuCQVzBCXpIIZ4pJUMENckgpmiEtSwQxxSSqYIS5JBTPEJalghrgkFcwQl6SCGeKSVDBDXJIKZohL\nUsEMcUkqmCEuSQUzxCWpYIa4JBXMEJekghniklQwQ1ySCmaIS1LBDHFJKpghLkkFM8QlqWCGuCQV\nzBCXpIJ1FeIR0R8RgxFxf0RcMcz2IyLi1ohYGxH3RsQ7et6pJGkPY4Z4REwDrgUWAqcCF0fE/I5p\ni4G1mXkG8BrgYxExvdfNSpJ2182e+ALggcx8NDO3ASuARR1zHgcOqZcPAX6emdt716YkaTjd7C3P\nBda3rQ9RBXu7G4BvRsRPgYOBt/SmPUnSaHp1yON9wLrMfE1EnAj8V0SclpnPdU5csmTJruWhWSdw\n0PGn9agFSZoaWq0WrVarq7mRmaNPiDgHWJKZ/fX6e4HMzA+3zfk68MHM/G69/k3gisz8QUetbL+9\npasG2bh5C49v3sKZ8w4dtY81Q5s4evZMjpk9kysXdh6Sl6SpKyLIzBhuWzfHxO8CToqI4yLiQOAi\n4JaOOQPAH9Q3dhRwMvBw85YlSd0Y83BKZu6IiMXAaqrQX56ZAxFxebU5lwEfAm6MiHVAAO/JzF/s\nzcYlSV0eE8/MlcApHWPXty0/Bbyht61JksbiJzYlqWCGuCQVzBCXpIIZ4pJUMENckgpmiEtSwQxx\nSSqYIS5JBTPEJalghrgkFcwQl6SCGeKSVDBDXJIKZohLUsEMcUkqmCEuSQUzxCWpYIa4JBXMEJek\nghniklQwQ1ySCmaIS1LBDHFJKpghLkkFM8QlqWCGuCQVzBCXpIIZ4pJUMENckgpmiEtSwQxxSSqY\nIS5JBTPEJalghrgkFcwQl6SCdRXiEdEfEYMRcX9EXDHCnL6IWBMR90XEbb1tU5I0nOljTYiIacC1\nwOuAnwJ3RcRXM3Owbc4c4B+B12fmhog4cm81LEn6rW72xBcAD2Tmo5m5DVgBLOqYcwlwc2ZuAMjM\np3rbpiRpON2E+Fxgfdv6UD3W7mTg8Ii4LSLuioi39qpBSdLIxjycMo46ZwGvBV4IfC8ivpeZD/ao\nviRpGN2E+Abg2Lb1efVYuyHgqczcAmyJiNuB04E9QnzJkiW/vdKsEzjo+NPG2bIkTW2tVotWq9XV\n3MjM0SdEHAD8mOrE5kbgTuDizBxomzMf+BTQD8wA7gDekpk/6qiV7be3dNUgGzdv4fHNWzhz3qGj\n9rFmaBNHz57JMbNncuXC+V39cJI0FUQEmRnDbRtzTzwzd0TEYmA11TH05Zk5EBGXV5tzWWYORsQq\n4B5gB7CsM8AlSb3X1THxzFwJnNIxdn3H+keBj/auNUnSWPzEpiQVzBCXpIIZ4pJUMENckgpmiEtS\nwQxxSSpYrz52P2ksXTU49qRh+AEiSSWaciEO8NzW7Ty7dXtXcw+ZMZ2DZ0zJu0HSfmBKptezW7fz\n+OYt3U2ePdMQl1SsKZ1e3XwfiySVzBObklQwQ1ySCmaIS1LBDHFJKpghLkkFM8QlqWCGuCQVzBCX\npIIZ4pJUMENckgpmiEtSwQxxSSqYIS5JBTPEJalghrgkFcwQl6SCGeKSVDBDXJIKZohLUsEMcUkq\nmCEuSQUzxCWpYIa4JBXMEJekghniklQwQ1ySCtZViEdEf0QMRsT9EXHFKPN+NyK2RcSbe9eiJGkk\nY4Z4REwDrgUWAqcCF0fE/BHmXQOs6nWTkqThdbMnvgB4IDMfzcxtwApg0TDz/hr4MvCzHvYnSRpF\nNyE+F1jftj5Uj+0SES8B3pSZnwaid+1JkkbTqxObnwDaj5Ub5JL0PJjexZwNwLFt6/PqsXZnAysi\nIoAjgfMjYltm3tJZbMmSJbuWh2adwEHHnzbeniVpSmu1WrRara7mdhPidwEnRcRxwEbgIuDi9gmZ\necLO5Yi4EfjacAEOu4f40lWDbNy8patGJWl/0dfXR19f3671q6++esS5Y4Z4Zu6IiMXAaqrDL8sz\ncyAiLq8257LOqzRpWpI0ft3siZOZK4FTOsauH2Hun/egL0lSF/zEpiQVzBCXpIIZ4pJUMENckgpm\niEtSwQxxSSqYIS5JBTPEJalghrgkFcwQl6SCGeKSVDBDXJIKZohLUsEMcUkqmCEuSQUzxCWpYIa4\nJBXMEJekghniklQwQ1ySCmaIS1LBDHFJKpghLkkFM8QlqWCGuCQVzBCXpIIZ4pJUMENckgpmiEtS\nwQxxSSqYIS5JBTPEJalghrgkFcwQl6SCGeKSVDBDXJIK1lWIR0R/RAxGxP0RccUw2y+JiHX15TsR\n8YretypJ6jRmiEfENOBaYCFwKnBxRMzvmPYw8OrMPB34AHBDrxuVJO2pmz3xBcADmfloZm4DVgCL\n2idk5vcz85l69fvA3N62KUkaTjchPhdY37Y+xOgh/RfArRNpSpLUnem9LBYRrwEuBc4dac6SJUt2\nLQ/NOoGDjj+tly1IUvFarRatVqurud2E+Abg2Lb1efXYbiLiNGAZ0J+ZT49UrD3El64aZOPmLV01\nKkn7i76+Pvr6+natX3311SPO7eZwyl3ASRFxXEQcCFwE3NI+ISKOBW4G3pqZDzXoWZLUwJh74pm5\nIyIWA6upQn95Zg5ExOXV5lwG/D1wOHBdRASwLTMX7M3GJUldHhPPzJXAKR1j17ctXwZc1tvWJElj\n8RObklQwQ1ySCmaIS1LBDHFJKpghLkkF6+knNqeqpasGG13vyoWd3xMmSb1liHfpua3beXbr9q7m\nHjJjOgfP8K6VtPeZNF16dut2Hu/2KwJmzzTEJT0vTJpxOnPeoaNuXzO06XnqRJI8sSlJRTPEJalg\nhrgkFcwQl6SCGeKSVDBDXJIKZohLUsEMcUkqmCEuSQUzxCWpYIa4JBXMEJekghniklQwQ1ySCmaI\nS1LBDHFJKpghLkkFM8QlqWCGuCQVzBCXpIIZ4pJUMENckgpmiEtSwQxxSSrY9H3dwP5q6arBRte7\ncuH8HnciqWSG+D703NbtPLt1e1dzD5kxnYNn+OuStLuuUiEi+oFPUB1+WZ6ZHx5mzieB84FfAu/I\nzLW9bHQqenbrdh7fvKW7ybNnGuKS9jDmMfGImAZcCywETgUujoj5HXPOB07MzJcDlwOfmWhjD6+7\nc6Iliql55rxDd13m/Pz+3dbPnHfohOu3Wq0J17CmNa05OWt2c2JzAfBAZj6amduAFcCijjmLgM8B\nZOYdwJyIOGoijT1yT+8Dt4Sae6PHyfrgs6Y1rTnxmt28Pp8LrG9bH6IK9tHmbKjHnphQdxqXkU6W\n/veDT416ItWTpVK5Js1B1jVDm3Zb37h5yx5j+0PNidYb7mTps1u3s3GYY+/dniy9/cGn+M5DT+02\nNtITw7knHsmrTzqyZzW7rWfN/bPmcPX2l5o7RWaOPiHiHGBJZvbX6+8Fsv3kZkR8BrgtM79Qrw8C\n52XmEx21Rr8xSdKwMjOGG+9mT/wu4KSIOA7YCFwEXNwx5xbgr4Av1KG/qTPAR2tCktTMmCGemTsi\nYjGwmt++xXAgIi6vNueyzPx6RFwQEQ9SvcXw0r3btiQJujicIkmavPzuFEkqmCEuSQWbFG8xrD8B\nuojqveVQvc/8lswc2Hdd7anucy5wR2Y+1zben5krG9Z8FfB0Zv4oIs4DzgbWZuY3e9J0dRufy8y3\n9bDeuVSfFbgvM1c3rPF7wEBmbo6Ig4D3AmcBPwKWZuYzDWq+C/hKZq4fc3L3NQ+kOpn/08z8RkRc\nAvw+MAAsqz8A16TuCcCbgZcCO4D7gZsyc3NvOtf+Yp8fE4+IK6je7bKC6oNEAPOo/nBWZOY1e+E2\nL83MG8d5nXdRvQNnADgDeHdmfrXedndmntWgj6XAa6leEbWAVwP/Cfwh1ZPYRxvUvKVzCHgN8C2A\nzHxjg5p3ZuaCevkyqvvhK8Drga81+R1FxA+B0zNze0QsA34FfBl4XT3+5gY1n6E6sf4Q8K/AlzLz\nyfHW6aj5L1Q7O7OATcDBwL/VfUZmvr1BzXcBfwzcDlwArKlr/wnwl5nZmkjP2jsi4sWZ+bN93cce\nMnOfXqj2QF4wzPiBVB/33xu3+ViD69wLHFwvvwz4AVWQA6xp2McPgQOoAmIzMLsePwhY17Dm3cA/\nA33AefW/G+vl8xrWXNO2fBfwonr5hcC9DWsOtPfcsW1t0z6pnhBfDywHngRWAm8HDmlY85763+lU\nn0A+oF6PndsaPpZ21pkFtOrlYyfwWJoDXAMMAr8Afk61w3ENcGiTmmPc3q0Nrzcb+BDweeCSjm3X\nNaw5D/hs/bPOAW6s7+PPAy9uWPPwjssRwE+Aw4DDG9bs7/h9LQfuAW4Cjmr6u5gMx8R/A7xkmPFj\n6m2NRMQ9I1zuBZp8r8u0rA+hZOZPqMLx/Ij4ONUfdBP/l5k7MvNXwENZv5TOzF/T/Gc/G/hf4P3A\nM1nt1f06M7+dmd9uWHNaRBwWEUdQhc+TdZ+/BLr7Lt093RcRO9+Kui4izgaIiJOBRocoqpbyN5m5\nOjPfSfW4ug7oBx5uWPOA+pDKIVSBO6cen0H1BNzUzkOZM6j27snMx4AXNKz3ReBpoC8zD8/MI6he\ngT1dbxu3iDhrhMsrqV6NNnEj1d/LzcBFEXFzRMyot53TsOY/AeuoXs3cQfVEdgFwJ/DphjWfovo7\n2nn5AdWh1Lvr5SaWti1/jGrn6g1UO0bXN6w5KfbE+4EHgVuBZfVlZT3WP4G6T1A90I7ruLyM6vjm\neOt9CzijY2w61Rd/7WjY4x3ArHp5Wsez9N1NarbVmAd8ieobKMf9yqOj1k+oQvCR+t9j6vGDab7X\nPIfqj++h+n7YVtf+NtXhlCY1R9yL3Xk/N6j5vrqvQeAyqmP2N1Dt6f1dw5rvptoDu6Gue2k9/iLg\n9oY1f9xk2xg1d9SP+9uGufy6Yc21HevvB75Ltafb6DHfXrPzsT7aY2KMmn9b59Ar2sYeaVKr7fp3\nty133g+N/o4yc9+HeP0DTKN6Fv7T+nIO9cvNCdRcDpw7wrabGtSbBxw9wrZXNexxxgjjR7Y/eCZ4\nP/wR1YnCvfF7mwUcP8Eas4HTgVcygZeUda2T99LPeRxwWL18AvBnTZ9o2mqeClwIzO9Rj6uB97Tf\nh1SvOK8AvtGw5n3Ay0fYtr5hzQHadljqsXdQHVp8tGHNdW3LH+jY1uhwX33dnTtCH6d6JfbwBH9H\nQ8Df1E8Qj1Cfk6y3NTo0l5n7/sSmpImLiMOo3uGzCHhxPfwE1VdiXJOZTzeoeSFVCP54mG1vysx/\nb1DzI8DqzPxGx3g/8Kms/k+C8db8B+Aj2faOsXr8JKqf/cLx1uyo80bgSuBlmXn0BOpc1TF0XWY+\nGRFHU/Xf6B1khrg0xTV5N5Y196hzENV/fHPfZOvTEJemuIh4LDOPtebUrDkpPuwjaWIi4p6RNtHs\n3VjWLKAmGOLSVHEU1f+D23nsO4D/seaUrWmIS1PEf1B9GG1t54aIaFlzytb0mLgklWwyfGJTktSQ\nIS5JBTPEJalghrgkFcwQl6SC/T+HcqrQCNdRMAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = range(16)\n", + "prob = [poisson(1.5, i) for i in x]\n", + "\n", + "pd.Series(prob, index=x).plot(kind='bar', lw=3,\n", + " color=\"#348ABD\", alpha=0.60,\n", + " edgecolor=\"#348ABD\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.arange(16)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/genetic_algorithm.ipynb b/genetic_algorithm.ipynb new file mode 100644 index 0000000..6066d51 --- /dev/null +++ b/genetic_algorithm.ipynb @@ -0,0 +1,549 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Genetic Algorithm\n", + "\n", + "The genetic algorithm emulates Evolution by \"breeding\" solutions from previous solutions and applying mutation. The likelihood that a solution \"survives\" is based on its \"fitness\" value (as defined by some \"fitness function\").\n", + "\n", + "### Problem to solve\n", + "\n", + "Let's try using it to solve a simple equation:\n", + "\n", + "* x − y = −1\n", + "* 3x + y = 9\n", + "\n", + "**(The real solution is x=2, y=3)**\n", + "\n", + "## Generic Genetic Algorithm\n", + "\n", + "First, let's write a basic genetic algorithm.\n", + "\n", + "Each \"individual\" will be a list in this form: [fitness, val1, val2, ...]" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import random\n", + "\n", + "def generate_couples(population):\n", + " couples = []\n", + " for i in range(0, len(population)-1, 2):\n", + " c = (population[i], population[i+1])\n", + " couples.append(c)\n", + " return couples\n", + "\n", + "def genetic_algorithm(fit_func, cross_func, mutate_func, init_pop, max_iter=1000,\n", + " max_pop=100, quit_at_err=0.01, mut_prob=0.1, mut_mu=0, mut_sigma=1):\n", + " population = init_pop\n", + " num_solutions_considered = 0\n", + " top_dog = init_pop[0]\n", + " \n", + " for i in range(max_iter): \n", + " # Calculate fitness function for each individual\n", + " for individual in population:\n", + " fitness = individual[0]\n", + " if fitness < 0: # Meaning it has not been calculated, since fitness is always positive or 0\n", + " fitness = fit_func(individual)\n", + " individual[0] = fitness\n", + "\n", + " # Sort population by fitness\n", + " population.sort()\n", + " top_dog = population[0]\n", + " num_solutions_considered += len(population)\n", + " if top_dog[0] < quit_at_err:\n", + " print('Generations: {}, Solutions considered: {}'.format(i, num_solutions_considered))\n", + " return top_dog\n", + " \n", + " # Make couples\n", + " couples = generate_couples(population)\n", + " \n", + " # Mate\n", + " babies = [mutate(have_sex(couple[0], couple[1]), mut_prob, mut_mu, mut_sigma) for couple in couples]\n", + " population += babies\n", + " \n", + " # Sort and cull\n", + " population.sort()\n", + " population = population[:max_pop]\n", + " \n", + " #print('Iteration {}, Population: {}'.format(i, len(population)))\n", + "\n", + " print('Generations: {}, Solutions considered: {}'.format(i, num_solutions_considered))\n", + " return top_dog\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Write problem-specific functions" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iterations: 39, # solutions considered: 3183\n" + ] + }, + { + "data": { + "text/plain": [ + "[0.0003454095730006291, 1.995886744141802, 3.01436163580238]" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def fitness_function(individual):\n", + " fitness, x, y = individual\n", + " # We square the error so it's always positive\n", + " eq1_error = ((x - y) - (-1))**2\n", + " eq2_error = ((3*x + y) - 9)**2\n", + " return eq1_error + eq2_error\n", + "\n", + "def have_sex(a, b):\n", + " x = a[1]\n", + " y = b[2]\n", + " return [-1, x, y]\n", + "\n", + "def mutate(a, mutation_probability, mu, sigma):\n", + " mutant = [-1]\n", + " for var in a[1:]:\n", + " if random.random() <= mutation_probability:\n", + " new_var = var + random.gauss(mu, sigma)\n", + " mutant.append(new_var)\n", + " else:\n", + " mutant.append(var)\n", + " return mutant\n", + "\n", + "initial_population = [[-1, 0, 0], [-1, 10, 10]] \n", + "most_fit_solution = genetic_algorithm(fitness_function, have_sex, mutate, initial_population)\n", + "most_fit_solution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Wow, so that's a pretty close solution in not too many generations (or solutions considered).**\n", + "\n", + "Now, let's compare it these 2 types of random searches:\n", + "\n", + "* Random walk\n", + "* Uniform random search (in a constrained window)\n", + "\n", + "## Comparison with random walk solution" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration: 0, Error: 58.197997727493785\n", + "Iteration: 10000, Error: 44847.096572963936\n", + "Iteration: 20000, Error: 26046.67741968994\n", + "Iteration: 30000, Error: 188915.547005843\n", + "Iteration: 40000, Error: 179066.1641331165\n", + "Iteration: 50000, Error: 98354.59650722975\n", + "Iteration: 60000, Error: 8099.110689885708\n", + "Iteration: 70000, Error: 22889.705969310067\n", + "Iteration: 80000, Error: 78947.95786648008\n", + "Iteration: 90000, Error: 81609.08510716847\n", + "Iteration: 100000, Error: 88042.48735877528\n", + "Iteration: 110000, Error: 127779.6609447398\n", + "Iteration: 120000, Error: 132049.4104383309\n", + "Iteration: 130000, Error: 30637.002742822388\n", + "Iteration: 140000, Error: 3029.9929598023473\n", + "Iteration: 150000, Error: 7267.082706040252\n", + "Iteration: 160000, Error: 12265.728575374562\n", + "Iteration: 170000, Error: 51693.022768068826\n", + "Iteration: 180000, Error: 54654.50564500899\n", + "Iteration: 190000, Error: 214919.2574790537\n", + "Iteration: 200000, Error: 233639.1235252252\n", + "Iteration: 210000, Error: 487713.4435635344\n", + "Iteration: 220000, Error: 308793.3769138881\n", + "Iteration: 230000, Error: 191308.4797177279\n", + "Iteration: 240000, Error: 170588.67097886262\n", + "Iteration: 250000, Error: 216560.60255446262\n", + "Iteration: 260000, Error: 267419.4993022812\n", + "Iteration: 270000, Error: 196970.79306162673\n", + "Iteration: 280000, Error: 137246.13771499082\n", + "Iteration: 290000, Error: 234730.14229765147\n", + "Iteration: 300000, Error: 316515.73946372623\n", + "Iteration: 310000, Error: 96594.69180194367\n", + "Iteration: 320000, Error: 130340.22848921012\n", + "Iteration: 330000, Error: 238135.03138638474\n", + "Iteration: 340000, Error: 178144.2447365376\n", + "Iteration: 350000, Error: 91122.51122254215\n", + "Iteration: 360000, Error: 129037.17506907361\n", + "Iteration: 370000, Error: 94361.99443001603\n", + "Iteration: 380000, Error: 71590.15927380601\n", + "Iteration: 390000, Error: 113332.32090784302\n", + "Iteration: 400000, Error: 82939.92711723235\n", + "Iteration: 410000, Error: 102994.44479207975\n", + "Iteration: 420000, Error: 167350.32331303938\n", + "Iteration: 430000, Error: 266967.33455625275\n", + "Iteration: 440000, Error: 322675.2160211878\n", + "Iteration: 450000, Error: 265426.0888841365\n", + "Iteration: 460000, Error: 95414.11415708082\n", + "Iteration: 470000, Error: 110365.3236887952\n", + "Iteration: 480000, Error: 214668.19020671965\n", + "Iteration: 490000, Error: 395312.02751460485\n", + "Iteration: 500000, Error: 661233.0135322829\n", + "Iteration: 510000, Error: 727568.1860427626\n", + "Iteration: 520000, Error: 543812.1712617927\n", + "Iteration: 530000, Error: 619007.9935390004\n", + "Iteration: 540000, Error: 597298.2276811234\n", + "Iteration: 550000, Error: 428322.09524126496\n", + "Iteration: 560000, Error: 609866.003075995\n", + "Iteration: 570000, Error: 745286.954889121\n", + "Iteration: 580000, Error: 852618.3208857924\n", + "Iteration: 590000, Error: 605701.2808994589\n", + "Iteration: 600000, Error: 751782.2243780773\n", + "Iteration: 610000, Error: 1285479.4597460038\n", + "Iteration: 620000, Error: 989334.980567904\n", + "Iteration: 630000, Error: 1337629.770909281\n", + "Iteration: 640000, Error: 1331822.0997493195\n", + "Iteration: 650000, Error: 1182752.318036363\n", + "Iteration: 660000, Error: 1643215.6954800738\n", + "Iteration: 670000, Error: 1564810.9477126657\n", + "Iteration: 680000, Error: 1629185.869107097\n", + "Iteration: 690000, Error: 2117395.143278152\n", + "Iteration: 700000, Error: 1648325.8893040004\n", + "Iteration: 710000, Error: 1782785.121202516\n", + "Iteration: 720000, Error: 1911100.8238497002\n", + "Iteration: 730000, Error: 1768831.9622492203\n", + "Iteration: 740000, Error: 1378838.7785962422\n", + "Iteration: 750000, Error: 1625563.5905535538\n", + "Iteration: 760000, Error: 1879327.6407330749\n", + "Iteration: 770000, Error: 1691495.5339371949\n", + "Iteration: 780000, Error: 1763827.414770319\n", + "Iteration: 790000, Error: 2626745.5558397365\n", + "Iteration: 800000, Error: 2390306.5618254687\n", + "Iteration: 810000, Error: 2264505.8102024305\n", + "Iteration: 820000, Error: 2431449.0096305464\n", + "Iteration: 830000, Error: 1461922.5381285502\n", + "Iteration: 840000, Error: 1815617.8344376218\n", + "Iteration: 850000, Error: 2624923.3861788064\n", + "Iteration: 860000, Error: 2696485.3145767944\n", + "Iteration: 870000, Error: 2386429.2533477843\n", + "Iteration: 880000, Error: 2416684.968660689\n", + "Iteration: 890000, Error: 1814027.4063623594\n", + "Iteration: 900000, Error: 1828885.0829097293\n", + "Iteration: 910000, Error: 1433186.612471411\n", + "Iteration: 920000, Error: 1316005.8469770257\n", + "Iteration: 930000, Error: 1152410.0941889544\n", + "Iteration: 940000, Error: 863993.5984905271\n", + "Iteration: 950000, Error: 844028.4266753952\n", + "Iteration: 960000, Error: 946837.0578228715\n", + "Iteration: 970000, Error: 955333.4077869634\n", + "Iteration: 980000, Error: 1078488.3699869053\n", + "Iteration: 990000, Error: 939357.1692977182\n", + "Iteration: 1000000, Error: 949823.6069154186\n" + ] + }, + { + "data": { + "text/plain": [ + "[-215.50760466522127, 754.9920021071864]" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def random_walk_next_solution(prev_solution, mu, sigma):\n", + " return [prev_solution[0] + random.gauss(mu, sigma), prev_solution[1] + random.gauss(mu, sigma)]\n", + "\n", + "def error_function(individual):\n", + " x, y = individual\n", + " # We square the error so it's always positive\n", + " eq1_error = ((x - y) - (-1))**2\n", + " eq2_error = ((3*x + y) - 9)**2\n", + " return eq1_error + eq2_error\n", + "\n", + "def do_random_walk_search(mu, sigma, init_guess, max_iter=100*10000+1, quit_at_err=0.01):\n", + " current_solution = init_guess\n", + " \n", + " for i in range(max_iter):\n", + " current_solution = random_walk_next_solution(current_solution, 0, .5)\n", + " current_solution_err = error_function(current_solution)\n", + " if current_solution_err < quit_at_err:\n", + " print('Solutions considered: {}, Error: {}'.format(i, current_solution_err))\n", + " break\n", + " if i % 10000 == 0:\n", + " print('Iteration: {}, Error: {}'.format(i, current_solution_err))\n", + " \n", + " return current_solution\n", + "\n", + "do_random_walk_search(0, 0.5, [0, 0])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "That is a pretty bad solution, and a ton of error.\n", + "\n", + "## Comparison with random (non-walk) solution" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration: 0, Error: 308.3127928505571\n", + "Iteration: 10000, Error: 4727.309365030706\n", + "Iteration: 20000, Error: 2702.1996692573516\n", + "Iteration: 30000, Error: 295.37602816058853\n", + "Iteration: 40000, Error: 2379.093086548179\n", + "Iteration: 50000, Error: 612.9270618824643\n", + "Iteration: 60000, Error: 5197.901755236507\n", + "Iteration: 70000, Error: 3201.8070554313686\n", + "Iteration: 80000, Error: 265.6679530549633\n", + "Iteration: 90000, Error: 2466.7681125102044\n", + "Iteration: 100000, Error: 602.9843901795197\n", + "Iteration: 110000, Error: 50.16423143387052\n", + "Iteration: 120000, Error: 450.2998350146081\n", + "Iteration: 130000, Error: 4908.17917978217\n", + "Iteration: 140000, Error: 153.68311282520978\n", + "Iteration: 150000, Error: 3180.767818636309\n", + "Iterations: 151234, Error: 0.006872960595740857\n" + ] + }, + { + "data": { + "text/plain": [ + "[1.970702724699727, 3.0275199352116857]" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def random_next_solution(x_min, x_max, y_min, y_max):\n", + " return [random.uniform(x_min, x_max), random.uniform(y_min, y_max)]\n", + "\n", + "def do_random_search(x_min, x_max, y_min, y_max, max_iter=100*10000+1, quit_at_err=0.01):\n", + " for i in range(max_iter):\n", + " # Note that with this solution, we are artificially limiting the search window\n", + " current_solution = random_next_solution(x_min, x_max, y_min, y_max)\n", + " current_solution_err = error_function(current_solution)\n", + " if current_solution_err < quit_at_err:\n", + " print('Iterations: {}, Error: {}'.format(i, current_solution_err))\n", + " break\n", + " if i % 10000 == 0:\n", + " print('Iteration: {}, Error: {}'.format(i, current_solution_err))\n", + "\n", + " return current_solution\n", + "\n", + "do_random_search(-20, 20, -20, 20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So looks like the random uniform search is descent (though nowhere near the efficiency as the Genetic Algorithm). BUT, we had to limit the search window for x and y to (-20, 20). The Genetic Algorithm is is really nice because no such limitation of the window is necessary. With some problems, we don't have such a good idea of where the solution (or a good-enough solution) lies.\n", + "\n", + "Now, look how poorly the random search algorithm behaves when we expand the window to (-100, 100):" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration: 0, Error: 87498.269900416\n", + "Iteration: 10000, Error: 19729.641085476345\n", + "Iteration: 20000, Error: 12088.16015937448\n", + "Iteration: 30000, Error: 70371.69304549509\n", + "Iteration: 40000, Error: 101228.17845615717\n", + "Iteration: 50000, Error: 3752.077746472049\n", + "Iteration: 60000, Error: 5678.870652708074\n", + "Iteration: 70000, Error: 13796.72050359031\n", + "Iteration: 80000, Error: 75143.37747065257\n", + "Iteration: 90000, Error: 45542.307427910455\n", + "Iteration: 100000, Error: 68761.573982296\n", + "Iteration: 110000, Error: 103085.07660772622\n", + "Iteration: 120000, Error: 3974.410160526244\n", + "Iteration: 130000, Error: 45856.8843360887\n", + "Iteration: 140000, Error: 82085.17905786278\n", + "Iteration: 150000, Error: 55998.276219948355\n", + "Iteration: 160000, Error: 13533.890847679402\n", + "Iteration: 170000, Error: 7714.684011843349\n", + "Iteration: 180000, Error: 86523.04016051191\n", + "Iteration: 190000, Error: 16543.62379364362\n", + "Iteration: 200000, Error: 16387.267717172082\n", + "Iteration: 210000, Error: 35095.89645941437\n", + "Iteration: 220000, Error: 21500.344783772187\n", + "Iteration: 230000, Error: 8602.127950229136\n", + "Iteration: 240000, Error: 23146.291821665374\n", + "Iteration: 250000, Error: 5573.538548409406\n", + "Iteration: 260000, Error: 15582.669051756802\n", + "Iteration: 270000, Error: 67460.89705168757\n", + "Iteration: 280000, Error: 22099.987714948118\n", + "Iteration: 290000, Error: 103875.00610584665\n", + "Iteration: 300000, Error: 34720.36015567349\n", + "Iteration: 310000, Error: 83594.23197451505\n", + "Iteration: 320000, Error: 12914.149660419593\n", + "Iteration: 330000, Error: 70952.46047816904\n", + "Iteration: 340000, Error: 59887.68169660277\n", + "Iteration: 350000, Error: 7520.050193027867\n", + "Iteration: 360000, Error: 44995.68257573622\n", + "Iteration: 370000, Error: 81291.94643393895\n", + "Iteration: 380000, Error: 41804.68036266295\n", + "Iteration: 390000, Error: 75533.79144602736\n", + "Iteration: 400000, Error: 40166.66863847164\n", + "Iteration: 410000, Error: 22777.252619958163\n", + "Iteration: 420000, Error: 33197.82810250713\n", + "Iteration: 430000, Error: 38228.650679926766\n", + "Iteration: 440000, Error: 23799.483498835998\n", + "Iteration: 450000, Error: 23362.13164486192\n", + "Iteration: 460000, Error: 55637.66175237792\n", + "Iteration: 470000, Error: 17834.702894950995\n", + "Iteration: 480000, Error: 8658.514188047018\n", + "Iteration: 490000, Error: 84567.11845740197\n", + "Iteration: 500000, Error: 94682.81767493288\n", + "Iteration: 510000, Error: 57374.14215140941\n", + "Iteration: 520000, Error: 133270.27557128755\n", + "Iteration: 530000, Error: 72186.95827586284\n", + "Iteration: 540000, Error: 3433.15872892808\n", + "Iteration: 550000, Error: 33586.914250072565\n", + "Iteration: 560000, Error: 68323.41411031733\n", + "Iteration: 570000, Error: 104327.49512416092\n", + "Iteration: 580000, Error: 58581.06509649316\n", + "Iteration: 590000, Error: 2425.8950816699307\n", + "Iteration: 600000, Error: 74158.4290486698\n", + "Iteration: 610000, Error: 59596.564761273505\n", + "Iteration: 620000, Error: 6032.790556750053\n", + "Iteration: 630000, Error: 19382.28625675643\n", + "Iteration: 640000, Error: 52113.27572042264\n", + "Iteration: 650000, Error: 16964.387182687533\n", + "Iteration: 660000, Error: 2566.9237548328633\n", + "Iteration: 670000, Error: 30745.90780684977\n", + "Iteration: 680000, Error: 9741.907422463612\n", + "Iteration: 690000, Error: 42375.54859504519\n", + "Iteration: 700000, Error: 35724.80283533997\n", + "Iteration: 710000, Error: 25734.247960276138\n", + "Iteration: 720000, Error: 8121.674922935857\n", + "Iteration: 730000, Error: 30344.43805352114\n", + "Iteration: 740000, Error: 48914.67262714829\n", + "Iteration: 750000, Error: 85613.73404147822\n", + "Iteration: 760000, Error: 17859.395898185354\n", + "Iteration: 770000, Error: 26279.316160791226\n", + "Iteration: 780000, Error: 2003.1869252535955\n", + "Iteration: 790000, Error: 70538.19320335564\n", + "Iteration: 800000, Error: 49188.62840047125\n", + "Iteration: 810000, Error: 20034.307571268408\n", + "Iteration: 820000, Error: 51024.020521718514\n", + "Iteration: 830000, Error: 33119.55340480031\n", + "Iteration: 840000, Error: 6755.657801786951\n", + "Iteration: 850000, Error: 22262.317303391013\n", + "Iteration: 860000, Error: 16174.411806687322\n", + "Iteration: 870000, Error: 26900.650286404183\n", + "Iteration: 880000, Error: 63639.462020066705\n", + "Iteration: 890000, Error: 1751.4986031186374\n", + "Iteration: 900000, Error: 130544.81195988822\n", + "Iteration: 910000, Error: 35406.58966007849\n", + "Iteration: 920000, Error: 9096.962857492243\n", + "Iteration: 930000, Error: 186.02024407888737\n", + "Iteration: 940000, Error: 16507.791284834748\n", + "Iteration: 950000, Error: 15890.978217479318\n", + "Iteration: 960000, Error: 21070.9556745879\n", + "Iteration: 970000, Error: 84199.18894773135\n", + "Iteration: 980000, Error: 11548.769004157894\n", + "Iteration: 990000, Error: 34477.79829390748\n", + "Iteration: 1000000, Error: 89978.66995960606\n" + ] + }, + { + "data": { + "text/plain": [ + "[-85.14712014026289, -30.728240396272312]" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "do_random_search(-100, 100, -100, 100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So when we expand the search space, the results are much worse for the uniform random search." + ] + } + ], + "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.5.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}