From 20d633db0d3d550dcdfd746773dd0d3ef54a7be2 Mon Sep 17 00:00:00 2001 From: alexc Date: Sat, 4 May 2019 12:11:39 +0100 Subject: [PATCH] Example notebook updated. --- notebooks/example.ipynb | 587 +++++++++++++++++++++++++++++++--------- 1 file changed, 464 insertions(+), 123 deletions(-) diff --git a/notebooks/example.ipynb b/notebooks/example.ipynb index ae947e7..fe4c68d 100644 --- a/notebooks/example.ipynb +++ b/notebooks/example.ipynb @@ -2,11 +2,19 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-05-04 11:52:13,271 Starting logging to console.\n" + ] + } + ], "source": [ - "## Examples for generation of PCFGs and plots of useful quantities.\n", + "## Example of the generation of a PCFG; and plots of useful quantities.\n", "import logging\n", "logging.basicConfig(level=logging.INFO,format='%(asctime)s %(message)s')\n", "logging.info(\"Starting logging to console.\")" @@ -14,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -30,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -41,91 +49,277 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "import pcfgfactory\n", "\n", + "\n", "pcfgfactory1 = pcfgfactory.PCFGFactory()\n", - "pcfgfactory1.lexical_distribution = pcfgfactory.LexicalPitmanYor()\n", + "pcfgfactory1.lexical_distribution = pcfgfactory.LogNormalPrior(sigma=3)\n", "pcfgfactory1.length_distribution.cds()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "pcfgfactory1.cfgfactory.number_terminals = 1000\n", - "pcfgfactory1.cfgfactory.number_nonterminals = 20\n", + "pcfgfactory1.cfgfactory.number_terminals = 20000\n", + "pcfgfactory1.cfgfactory.number_nonterminals = 10\n", "pcfgfactory1.cfgfactory.binary_rules = 40\n", - "pcfgfactory1.cfgfactory.lexical_rules = 1000\n", + "pcfgfactory1.cfgfactory.lexical_rules = 20000\n", "\n", + "# Parameters for controlling how we train the binary rule parameters.\n", + "pcfgfactory.LENGTH_EM_ITERATIONS = 100\n", + "## A limit on the length of examples for efficiency purposes.\n", "\n", - "upcfg = pcfgfactory1.sample()\n" + "pcfgfactory.LENGTH_EM_MAX_LENGTH = 30\n", + "# This parameter controls how close the length distribution of the grammar needs to be\n", + "# to the desired distribution.\n", + "## This is very close and may be slow to converge.\n", + "pcfgfactory.TERMINATION_KLD = 0.01" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ - "# This is a stupid way of doing it but included to justify the less stupid way.\n", - "# We will end up with a grammar with expected length just over 1.\n", - "#upcfg = pcfgfactory1.sample_naive()" + "import random\n", + "import numpy.random\n", + "seed = 1 # was 4\n", + "random.seed(seed)\n", + "rng = numpy.random.RandomState(seed = seed)\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-05-04 11:53:08,978 CFG nominally has 10 nonterminals, 20000 terminals, 40 binary_rules and 20000 lexical rules\n", + "2019-05-04 11:53:09,068 Final CFG has 10 nonterminals, 13027 terminals, 40 binary_rules and 20000 lexical rules\n", + "2019-05-04 11:53:09,089 Training with LENGTH_EM_MAX_LENGTH 30 \n", + "2019-05-04 11:53:09,090 Target LP = -467567.506811, -467567.506811\n", + "2019-05-04 11:53:09,091 Starting EM iteration 0, target = -467567.506811\n", + "2019-05-04 11:53:10,070 LP = -929020.639481\n", + "2019-05-04 11:53:10,071 KLD from target 2.317230\n", + "2019-05-04 11:53:10,073 Starting EM iteration 1, target = -467567.506811\n", + "2019-05-04 11:53:10,933 LP = -486424.191034\n", + "2019-05-04 11:53:10,935 KLD from target 0.094691\n", + "2019-05-04 11:53:10,936 Starting EM iteration 2, target = -467567.506811\n", + "2019-05-04 11:53:11,800 LP = -478830.877338\n", + "2019-05-04 11:53:11,802 KLD from target 0.056560\n", + "2019-05-04 11:53:11,802 Starting EM iteration 3, target = -467567.506811\n", + "2019-05-04 11:53:12,691 LP = -474596.526889\n", + "2019-05-04 11:53:12,692 KLD from target 0.035297\n", + "2019-05-04 11:53:12,693 Starting EM iteration 4, target = -467567.506811\n", + "2019-05-04 11:53:13,576 LP = -472190.811925\n", + "2019-05-04 11:53:13,577 KLD from target 0.023216\n", + "2019-05-04 11:53:13,578 Starting EM iteration 5, target = -467567.506811\n", + "2019-05-04 11:53:14,440 LP = -470816.995614\n", + "2019-05-04 11:53:14,441 KLD from target 0.016318\n", + "2019-05-04 11:53:14,442 Starting EM iteration 6, target = -467567.506811\n", + "2019-05-04 11:53:15,329 LP = -470028.352626\n", + "2019-05-04 11:53:15,331 KLD from target 0.012357\n", + "2019-05-04 11:53:15,331 Starting EM iteration 7, target = -467567.506811\n", + "2019-05-04 11:53:16,227 LP = -469569.375590\n", + "2019-05-04 11:53:16,228 KLD from target 0.010053\n", + "2019-05-04 11:53:16,229 Starting EM iteration 8, target = -467567.506811\n", + "2019-05-04 11:53:17,106 LP = -469294.517470\n", + "2019-05-04 11:53:17,107 KLD from target 0.008672\n", + "2019-05-04 11:53:17,107 Converged enough. 0.008672 < 0.010000 \n" + ] + } + ], "source": [ - "# Actaul nonterminals and terminals in the trimmed grammar may be below the nominal values.\n", - "print(len(upcfg.nonterminals),len(upcfg.terminals),len(upcfg.productions))\n" + "upcfg = pcfgfactory1.sample() " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "4.687471125841121" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "import uniformsampler\n", - "max_length = 20\n", - "\n", - "us = uniformsampler.UniformSampler(upcfg,max_length)" + "upcfg.expected_length()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "['dbvvh',\n", + " 'oudff',\n", + " 'vnrku',\n", + " 'hfgar',\n", + " 'vgxdb',\n", + " 'tiwfr',\n", + " 'efhcm',\n", + " 'xlzgl',\n", + " 'dzogf',\n", + " 'vnrku',\n", + " 'avigd',\n", + " 'avigd']" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "x = range(1,max_length+1)\n", - "plt.plot(x, [ us.get_total(l) for l in x], label=\"Derivations\")\n", - "plt.yscale('log')\n", - "plt.xticks(x)\n", - "plt.xlabel(\"Length\")\n", - "#plt.ylabel(\"Number of derivations\")\n", - "plt.plot(x, [ len(upcfg.terminals) ** l for l in x ], label=\"All strings\")\n", + "rng = numpy.random.RandomState(seed = seed)\n", + "sampler = pcfg.Sampler(upcfg,random=rng)\n", + "sampler.sample_string()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Empirical Mean 4.665200\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "target = pcfgfactory1.length_distribution.weights\n", + "L = len(target)\n", + "lpcfg = upcfg.make_unary()\n", + "linsider = inside.UnaryInside(lpcfg)\n", + "table = linsider.compute_inside_smart(L)\n", + "\n", + "showall = False\n", + "if showall:\n", + " ## Here we print the distributions for each nonterminal.\n", + " for k,nt in enumerate(linsider.nts):\n", + " x = []\n", + " y = []\n", + " for i in range(1,L):\n", + " x.append(i)\n", + " p = table[i,k]\n", + " y.append(p)\n", + "\n", + " ## Plot the true distribution of lengths.\n", + " plt.plot(x,y, 'b',label = nt,alpha=0.25)\n", + " #plt.yscale('log')\n", + "else:\n", + " x = []\n", + " y = []\n", + " k = linsider.ntindex['S']\n", + " for i in range(1,L):\n", + " x.append(i)\n", + " p = table[i,k]\n", + " y.append(p)\n", + "\n", + " ## Plot the true distribution of lengths.\n", + " plt.plot(x,y,'g', label = 'Grammar')\n", + " \n", + " n_samples = 10000\n", + " total = 0.0\n", + " n = 0\n", + " \n", + " lengths = Counter()\n", + " for i in range(n_samples):\n", + " try:\n", + " s = utility.collect_yield(sampler.sample_tree())\n", + " lengths[len(s)] += 1\n", + " total += len(s)\n", + " n += 1\n", + " except ValueError:\n", + " pass\n", + " print(\"Empirical Mean %f\" % (total/n))\n", + "\n", + "\n", + " x = range(1, L)\n", + " y = [ lengths[i]/n for i in x]\n", + " plt.plot(x,y,label=\"Sampled\")\n", + "## Plot the desired distribution of lengths.\n", + "\n", + "xt = range(1, len(target))\n", + "yt = [ target[i]/sum(target) for i in xt]\n", + "plt.plot(xt,yt,\"r:\",label = \"Target\")\n", "plt.legend()\n", + "plt.ylabel(\"Probability\")\n", + "plt.xlabel(\"Length\")\n", + "#plt.xticks(x)\n", + "#plt.yscale('log')\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('S', ('NT6', ('NT7', ('NT2', 'fqgpo'), ('NT2', 'gzutb')), ('NT9', ('NT2', 'lsxiq'), ('NT1', ('NT5', ('NT9', 'himze'), ('NT5', 'fabwk')), ('NT5', ('NT1', ('NT1', ('NT5', ('NT1', ('NT5', 'vqvop'), ('NT4', ('NT6', ('NT7', ('NT8', 'xkhra'), ('NT7', 'jlqkg')), ('NT9', 'xarfy')), ('NT9', 'utbvv'))), ('NT4', 'grbsu')), ('NT4', ('NT6', ('NT9', 'fpqki'), ('NT5', ('NT7', ('NT8', 'lktyh'), ('NT7', 'zbdrg')), ('NT2', 'trtdw'))), ('NT4', 'vmdks'))), ('NT6', 'gxixf')), ('NT2', 'ncqtd'))))), ('NT6', ('NT1', 'rjdqq'), ('NT8', 'fncow')))\n", + "['fqgpo', 'gzutb', 'lsxiq', 'himze', 'fabwk', 'vqvop', 'xkhra', 'jlqkg', 'xarfy', 'utbvv', 'grbsu', 'fpqki', 'lktyh', 'zbdrg', 'trtdw', 'vmdks', 'gxixf', 'ncqtd', 'rjdqq', 'fncow']\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ + "import uniformsampler\n", + "rng = numpy.random.RandomState(seed = seed)\n", + "max_length = 40\n", + "\n", + "us = uniformsampler.UniformSampler(upcfg,max_length,rng)\n", "\n", "\n", - "t10 = us.sample(14)\n", + "\n", + "t10 = us.sample(20)\n", "print(t10)\n", "\n", "print(utility.collect_yield(t10))\n", @@ -137,12 +331,85 @@ "execution_count": null, "metadata": {}, "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "x = range(1,max_length)\n", + "plt.plot(x, [ utility.catalan_numbers(i) for i in x ], label=\"Catalan\")\n", + "plt.plot(x, [ us.get_total(l) for l in x], label=\"Derivations\")\n", + "plt.yscale('log')\n", + "#plt.xticks(x)\n", + "plt.xlabel(\"Length\")\n", + "#plt.ylabel(\"Number of derivations\")\n", + "plt.plot(x, [ len(upcfg.terminals) ** l for l in x ], label=\"All strings\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The density of a language at length $n$ is the probability that a randomly selected (uniformly drawn) string of length $n$ has non zero probability; i.e. is in the support of the language. The crude method doesn't work well for low density languges; so we use a smarter way by sampling from derivations of strings of length $n$.\n", + "Note that this is entirely non-probabilistic." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "10\n", + "11\n", + "12\n", + "13\n", + "14\n", + "15\n", + "16\n", + "17\n", + "18\n", + "19\n" + ] + } + ], "source": [ "x = []\n", "yc = []\n", "y = []\n", "n_samples = 100\n", - "for l in range(1,max_length+1):\n", + "max_length = 20\n", + "for l in range(1,max_length):\n", + " print(l)\n", " x.append(l)\n", " y.append(us.string_density(l,n_samples))\n", " yc.append(us.string_density_crude(l,n_samples))" @@ -150,74 +417,98 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "\n", "plt.plot(x,y,'rx-',label=\"derivation sampler\")\n", "plt.plot(x,yc,'bx-',label=\"string sampler\")\n", - "plt.plot([1,max_length+1],[1.0,1.0],'r:')\n", + "plt.plot([1,max_length],[1.0,1.0],'r:')\n", "plt.xlabel(\"Length\")\n", "plt.ylabel('Density')\n", "plt.yscale('log')\n", - "plt.xticks(range(1,max_length+1))\n", + "#plt.xticks(range(1,max_length+1))\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Length distribution.\n", - "lpcfg = upcfg.make_unary()\n", - "linsider = inside.InsideComputation(lpcfg)\n", - "L = 21\n", - "a = pcfg.UNARY_SYMBOL\n", - "x = []\n", - "y = []\n", - "for i in range(1,L):\n", - " x.append(i)\n", - " s = (a,) * i\n", - " p = math.exp(linsider.inside_log_probability(s))\n", - " y.append(p)" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "## Plot the true distribution of lengths.\n", - "plt.plot(x,y, label = \"Grammar\")\n", - "## Plot the desired distribution of lengths.\n", - "target = pcfgfactory1.length_distribution.weights\n", - "xt = range(1, len(target))\n", - "yt = [ target[i]/sum(target) for i in xt]\n", - "plt.plot(xt,yt,\"r:\",label = \"Target\")\n", - "plt.xlabel(\"Probability\")\n", - "plt.ylabel(\"Length\")\n", - "plt.xticks(x)\n", - "plt.legend()\n", + "# Lexical distribution\n", + "te = upcfg.terminal_expectations()\n", + "probs = [ te[a] for a in te]\n", + "probs.sort(key = lambda x : -x)\n", + "ranks = np.arange(1, len(probs)+1)\n", + "plt.plot(ranks, probs, rasterized=True,marker=\".\")\n", + "n = len(te)\n", + "plt.plot([1,n],[1,1/n],'r')\n", + "plt.yscale('log')\n", + "plt.xscale('log')\n", + "plt.xlabel('Rank')\n", + "plt.ylabel('Expectation')\n", + "\n", + "plt.title(\"lexical rank expectation plot\")\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEaCAYAAAAG87ApAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xl4VOX1wPHvSQIEAVnjwg4SEAQFQbBqEasICgjugFoXBFFRUeuvqG3VutFWEVEqglJcAIu4VFyKuCClIoUoCoosYgIBFdAQ2SHJ+f3xTmQIM5k7yUxmO5/nyfNk7ty5c+Ym5PC+511EVTHGGGO8Sot1AMYYYxKLJQ5jjDFhscRhjDEmLJY4jDHGhMUShzHGmLBY4jDGGBMWSxwmbCKSKyJnReA6O0SkdSWvMU1EHqhsLB7fq5eI5Idx/gMislVEvo9mXIlIRK4SkYWxjsNUjCUOEzOqWltV18U6jmgQkWbA7UAHVT0q1vEkMhGZLyLXxjoOc4AlDpMyRCSjCt+uBfCjqm6Og1iMiShLHKZSRCRNRMaIyDci8qOIzBKRBr7nLhWRdSJyuO/xOSLyvYhk+R6riLTxfV9TRB4VkTwRKRSRhSJS0/fcy77XFYrIAhE5zmNsV4nIf0XkMRH5CbhXRI4RkQ98sW4VkekiUs/vNbki8jsR+cL3fv8Ukcwg179ZRL4SkaZljp8FzAMa+7rjpolIS9/nHSYi64EPfOeeLCIfi8g2EflcRHr5XaeViHwkIttFZJ6IPCkiL/qeO6TbzL8LMcTPpTSWK0Vkve8+3O13nXQRucv32u0ikiMizURkoog8WuY954jI6CD3R333aJ3vPf4mIgH/5ojIKSKyxHfPl4jIKb7jDwK/Bp703csnA73eVDFVtS/7CusLyAXO8n0/GvgEaArUAJ4GZvqdOx2YBjQENgH9/Z5ToI3v+4nAfKAJkA6cAtTwPXcNUMd3/fHAMr9rTAMeCBLnVUARcBOQAdQE2gC9fdfKAhYA48t8tv8BjYEGwEpgpO+5XkC+7/s/Ap8CWUHe+5dzfY9b+j7v80AtXyxNgB+Bc3H/ievte5zle80iYJwv1p7AduDFQNcP5+fiF8sUXxwnAHuB9r7n7wCWA+0A8T3fEOju+xmm+c5rBOwCjgxyDxT40HcfmwOrgWv9fjYLfd83AAqAK3w/pyG+xw19z88vfZ19xcdXzAOwr8T7KvMHaiVwpt9zRwP7gQzf43rAet8foqfLXEd9f8jTgN3ACR7eu57vdXV9j6dRfuJYH+J6g4DPyny2y/0e/xWY5Pu+F7DR98d8YWkMQa570B92vz/Wrf2O/R54oczr5gJX+v7QFgG1/J6bgffEEfTn4hdLU7/n/wcM9n2/ChgY5HOtBHr7vh8FvF3OPVCgr9/jG4D3/X42pYnjCuB/ZV67CLjK970ljjj7sq4qU1ktgNd8XS3bcH9YioEjAVR1G/Ay0BF4NMg1GgGZwDdln/B1m4z1dZv8jPvjWPoaLzaUud4RIvKSiGz0Xe/FANfyHwW1C6jt97geMAJ4WFULPcYQLJ4WwMWl9853/07D/ZFvDBSo6k6/8/PCeJ9yfy4+wT5nMwL8LHyeAy73fX858EKIOPw/bx7uc5XVmEM/Wx6uRWbikCUOU1kbgHNUtZ7fV6aqbgQQkc64rqaZwIQg19gK7AGOCfDcUGAgcBZQF/e/ZXBdKF6UXf75Yd+x41X1cNwfP6/XAteF0h/4h4icGsbrAsWzAdfi8L93tVR1LPAdUF9Eavmd39zv+53AYaUPRCQd1/Xmf+2gP5cQNhD4ZwEu0Q4UkROA9sDrIa7VrEz8mwKcswmX6ChzbmmstoR3nLHEYSprEvCgiLQAEJEsERno+z4T94fmLuBqoImI3FD2AqpaAkwFxolIY18r41ciUgNX29iL6/s/DHiokvHWAXYA20SkCa4/PyyqOh+4DPc/+h6ViOVFYICI9PF95kxf0bupquYBS4H7RKS6iJwGDPB77WogU0T6iUg14A+4WkapoD8XD54B7heRbHGOF5GGvs+eDyzBtTReUdXdIa51h4jUFzc8+RbgnwHOeRtoKyJDRSRDRC4FOgBv+p7/AajUfB8TWZY4TGU9DrwBvCsi23EF2dI/pg/j+uGfUtW9uP/dPyAi2QGu8ztcHWQJ8BPwF9zv5/O4bouNwFe+61fGfcCJQCHwFvBqRS6iqvNwyfANEelawWtswLWm7gK24P6nfwcH/l0Oxd3Ln4B7cPei9LWFuJrBM7h7sxPwH2VV3s8llHHALOBd4GfgWVwRvdRzQCdCd1MB/AvIAZbh7vezZU9Q1R9xrbjbcf9B+D/cIIqtfp/lIhEpEJFgrVZThUTVWoHGJAIRuRc3Cu3yUOdGOY6euNZSS19rMdh5CmSr6toqC85UCWtxGGM883WL3QI8U17SMMnNEocxxhMRaQ9sw436Gh/jcEwMWVeVMcaYsFiLwxhjTFgscRhjjAlLUq3QKSIDgAF16tQZ3rZt21iHY4wxCSUnJ2erqmaFOi8paxzdunXTpUuXxjoMY4xJKCKSo6rdQp1nXVXGGGPCYonDGGNMWCxxGGOMCYslDmOMMWGJ+1FVvmWl/w7sA+ar6vQYh2SMMSktJi0OEZkqIptFZEWZ431FZJWIrBWRMb7DFwCzVXU4cF6VB2uMMeYgseqqmgb09T/g24hmInAObi3+ISLSAbdncukuYsVRjeqzz2Dx4qi+hTHGJLqYJA5VXYDbY8Bfd2Ctqq5T1X3AS7i9CvJxyQPKiVdERojIUhFZumXLlooFdv/9cPLJcOqp8MorUBzdPGWMMYkonorjTTh4f+J837FXgQtF5ClgTrAXq+pkVe2mqt2yskJOfAzsuefg8cfhu+/goosgO9s93r69YtczxpgkFE+JI9C+z6qqO1X1alW9PlRhXEQGiMjkwsLCikVQpw7cfDOsWeNaHI0bw+jR0KwZ3HEHrF9fsesaY0wSiafEkc/BG9s3JfDG9kGp6hxVHVG3bt3KRZKeDhdcAAsXwiefQN++8Nhj0Lo1DBkCS5ZU7vrGGJPA4ilxLAGyRaSViFQHBuP2TPas0i2OQHr0gJdegm++ca2Pt9+G7t3h17+G116zOogxJuXEajjuTGAR0E5E8kVkmKoWAaOAucBKYJaqfhnOdSPW4gikRQt45BHYsMG1PjZscK2Stm3hiSdgx47Iv6cxxsShpFodt3RZ9TZt2gxfs2ZNdN+sqMi1OMaNc91Z9erBddfBqFHQtGno1xtjTJxJydVxK9viyMn9iYkfriUnryD0yRkZcPHFsGgRfPwx9O4Nf/sbtGoFl18OOTkVisEYY+KdtTh8cvIKuOTpRRSXKOlpws1nZnNR16Y0rpuJSKABXwF8+63rtnrmGTeE9/TT4bbboH9/SEuqHG2MSUJeWxxJlThKVWQjp4kfruWRuasoezeOOjyTri3qc2KL+nRtUZ8ORx9O9YwQSaCw0CWPxx93tZA2beDWW+HKK6FWrfA+jDHGVJGUTByVbXFc9swn7C8qoVpGGvcP7Mju/cUszS0gJ6+Ajdt2A1AjI40Tmtb7JZGc2LweDWvXCHzRoiI3H+TRR90Q3vr1YeRIVwdp3LiSn9YYYyIrJRNHqYpuHZuTV8An637k5NYN6dqi/kHPfV+4h0/XuySSk1fAl5sK2V/s7l2rRrU4sblLJF1b1Cf7iNqkpfl1b6m6Osi4ca6gnpEBgwe7VkiXLpX6rMYYEymWOKK85/ie/cUs31j4SyL5NK+AH3fuA6BOZgZdmtenqy+ZIPD5hm0uIRX9BBMmwLPPws6dcMYZrg5y7rlWBzHGxJQljignjrJUlbwfd7lEst4lklU/bMf/9lZLF14afjJdWzaAbdtgyhSXRPLz3XyQW2+F3/4WDjusSmM3xhhI0cRRpfM4PPh5z37un/MVs3Pyfym6N66XyRNDutC1RQN3YP9+mD3b1UFycqBBA7j+erjxRjj66JjFboxJPTaPIw4cnlmNwd2bU6NaGuniWhy79xVz4VOLuO6FpXyzZQdUq3Zg/asFC6BnT3joITdT/aqr4PPPY/0xjDHmIEnV4igVi66q8vgX3dsfXYdn//Mtkz76hj1FJQw+qRm3nJXNEXUyD7xg7Vo3lHfqVNi1C84809VB+va1OogxJmpSsquqVLwljkC27tjLhPfXMGPxeqpnpDGiZ2uG/7o1tWr4bQNfUACTJ7s6yKZNcOyxrg5yxRVQs2bsgjfGJKWUTBzxVuPw4tutO/nb3K95e/n3NKpdg9FnZXPpSc2olu7Xsti3D15+2dVBPvsMGjVydZAbboCjjopd8MaYpJKSiaNUIrQ4yvp0fQEPv72SJbkFtM6qxUVdm6KqnNy60YE5JaquDjJuHMyZ4+ojl13mWiGdOsX2AxhjEp4ljgRLHOCG9M776gfunfMlm7btAdxM9RnDTz5kQiKrV7s6yD/+Abt3u0UWb7sN+vQBr2trGWOMn5QcVZXoRISzjzuKId2b/7KP7t6iEl77NP/Qk9u2hYkT3VpYDz0EK1bAOedAx45unaw9e6o0dmNM6rDEEYdOOaYRNaqlkSZuI/aXlm5gzudBdtFt2BDuvBNyc+H551331fDh0Lw53HcfbN5claEbY1JAUnVVJWJxPJjSIbwdjq7D3+d/w5LcAm49qy03n9mm/GXeVWH+fFcHefNNqFHDjcIaPRqOO67K4jfGJB6rcSRgjSOYvUXF3Pnqcl79dCMDOzfmLxceT2a19NAv/PprVweZNs11XfXt6wrpvXtbHcQYcwircSSRGhnpPHrxCdzRpx3/WraJoVM+Ycv2vaFfeOyx8NRTrg5y//1uKG+fPnD88W5yodVBjDEVYIkjQYgIN57Rhr9fdiJfffczgyb+l1Xfb/f24kaN4A9/gLw8NwpLBIYNc8ua3H8/bNkS3eCNMUnFuqoS0OcbtnHt80vZva+YW87KZl9RScA9RIJShfffd3WQd96BzEy3Ku/o0dC+fXSDN8bELatxJHHiANi0bTdDp3xC7o+7AMhIEx4+vxMXdG1KeloY9YuvvoLx492IrL173b4gt90Gv/mN1UGMSTGWOJI8cQCMn7eax99fc9A+6YdnZtCjdUNOOaYhdWtW47vC3QfPPg9myxZXD5k40Q3hPf54l0AGD3Yjs4wxSS9pEoeItAbuBuqq6kVeXpMqicN/n/SM9DSu73UM323bw6J1P7L+p12/nFctXZgx/GROatkg9EX37IEZM1w31pdfurWwRo1ye6U3bBjFT2OMibW4SBwiMhXoD2xW1Y5+x/sCjwPpwDOqOtbDtWZb4jhUsH3SH357JZMXrPulNVLvsGrcec6xnN+lKcs3FgbdW/0XqjBvnksgc+e61XivvNLVQdq1i/4HM8ZUuXhJHD2BHcDzpYlDRNKB1UBvIB9YAgzBJZGHy1ziGlXd7HudJY4w+LdG0tKEZvVrsm7rLhrWqk7h7v2UqFI9I43p1wZYB6usFStcHeTFF10dpH9/143Vq5fVQYxJInExj0NVFwA/lTncHVirqutUdR/wEjBQVZerav8yX57XyxCRESKyVESWbrHhpXRtUZ/p157MbWe346URv+L923vx3DXdqVktnaISpURh7/4SPlrt4RaXrn+Vlwf33AOLF7vi+YknwgsvuGXfjTEpIxbzOJoAG/we5/uOBSQiDUVkEtBFRO4Mdp6qTlbVbqraLSsrK3LRJrCuLepz4xlt6NqiPiLC6W2zeHxIF6r79vpQ4Jn/fMsjc1fx4arNTPxwLTl5BcEveOSRcO+9LoFMmeJaH7/9LbRsCQ8/DD+V/T+CMSYZRb04LiItgTf9uqouBvqo6rW+x1cA3VX1pgi8V9KsVRVNpXWRI2rX4INVm3lnxfeAW1CxRjWP3VcAJSXw7ruuDjJvHhx2mNsnffRoyM6O6mcwxkReXHRVBZEPNPN73BQIsvRreFR1jqqOqFu3biQul7RKWyIXn9SMpy7vyjWntQRcC2RfUQmfrPvR24XS0tz6V+++C198AZde6rq02rWDgQPho49ckd0Yk1RikTiWANki0kpEqgODgTcicWERGSAikwsLCyNxuZTRr1NjMjPcr0KJUrE/9p06ufWv8vLc8ib//a8rnnfrBtOnw/79EY3ZGBM7UU0cIjITWAS0E5F8ERmmqkXAKGAusBKYpapfRjMOU76uLeozffjJ3HJmNm2PrM1j763hqflrQ9c8AjnqKPjzn93Cik8/DTt3wuWXQ6tW8Je/QEGY1zPGxJ24nwBYETYct+K279nPBX//mDWbdyBARrow5pxjaVSrBvnbdnmbhe6vpAT+/W9XB3n/fahVC66+Gm65Bdq0idrnMMaELy7mccSKJY7KGffuKiZ8sDbgc5nhFM/L+vxzeOwxNzO9qMjVQW67DU47zeaDGBMH4rk4HjVW44iM09sdQWa1NNIFamSk0bvDkb/sgb5nfwn/WV3BeTInnOA2lcrLg7vuggULoGdP6N4dZs60OogxCcJaHCYg/6VMAC575hP27i9Bgab1a3J+lyb0ancEwEHnBfo+aOtk1y63Ku9jj8Hq1dC0Kdx8s9szvV69qH9GY8zBUrKryuZxRE9pItm0bTfTF6//5biIG4SVJm6zqZISJS0NBKFElfQ04aKuTbmoa7PgCaSkBN56y9VB5s+H2rXdRlM33wytW1fNBzTGpGbiKGUtjuiZ+OFaHn13lRu2G4Z0gQEnNKZ7q4YU7NoXvCXy2WeuBTJzpkso55/v6iC/+pXVQYyJMkscljiiwn/xxHTXzKC42Pc9QnGJW1RRFYpLlEC/XZ5mqG/c6PYGmTTJDeHt0cMlkAsugIyMKH5CY1JXSiYO66qqGmXrH8G+f+XTfGbn5LO/qOSQBJImcPvZ7bjxjBBDcnfudAX18eNh7Vpo3twN5R02DGyFAGMiKiUTRylrccSPnLyCXxJIUVEJJX7PXdS1CSc2b1B+11Wp4mJ4801XB1mwAOrUgWuvdXWQli2j/TGMSQmWOCxxxJXSVkr9w6rznzVbfllYEVzXVbV0oVe7I8iqU4MLTmxafhJZutTVQWbNcnWQCy903Vgnnxz9D2JMErPEYYkjbk38cC2PzF0VsP4BUD0jjZnDPUwy3LABnnzSLW1SWOgK6LfdBoMGWR3EmApIyQmAJjGc3LohNaqlBf3l21dUwn1vrODu15aXv1ZWs2Zu/av8fJgwAX74AS6+2C3pPn48/PxzVOI3JtUlVYvDiuOJw7/rasWmQmYt3UBR8aG/i9XT05g5wuMSJ8XF8MYbrg6ycCEcfribTHjzza6obowpl3VVWVdVQikton+5sZDP8w9eMqb9UXXo3LwenZrU81ZIB/jf/1wd5OWX3eOLLnLdWN27R+kTGJP4LHFY4khIOXkFDJm8iH0BWh9QgV0K16+HJ56AyZNd19Wpp7oEMnAgpKdHNnhjEpwlDkscCau81kepNlm1aJ1V29soLIDt291GU+PHQ26u2x9k9Gi3xHudOpH/EMYkIEscljgSXqjWR6l0Ee4f1JGhPTzUMYqK4F//cnWQjz92kwhHjICbbnLFdmNSWEomDiuOJ5/S1ocAW7bv5d2vfgh67kkt6tP2qDreWiAAn3zi6iCzZ7t1sC65xHVjdQv578aYpJSSiaOUtTiSk9cWiAAntaxP9pEek0hurquDTJniurR+/WuXQAYMsDqISSmWOCxxJKXSFsjW7XvZtmsfS/IKKO9XOA3o1tIljp927qN1Vm2uO/2YwMnk55/h2Wfh8cfdZlPHHHOgDlKrVnQ+kDFxxBKHJY6UMGPxev74+nJCNEIO0aR+TZrUzQzcKikqgtdeg0cfhcWLoX59uO46GDUKmjSJ7AcwJo5Y4rDEkTJKWyFrf9jO0ryCsPcKAWhzRG2uObXVoQX2RYtcIf3VVyEtDQYPhltvhRNPjEzwxsQRSxyWOFJSZZNI03qZ3HBG9qEJ5Ntv3bImzzwDO3bA6ae7Okj//i6hGJMELHFY4kh5ZeshG7ftZuO2PZ5ee9ThNTjy8EwuPan5wUmksNAV0SdMcIssZme7OsiVV1odxCS8pEocIjII6AccAUxU1XfLO98ShwkmJ6+ASR99w1ebCtm0bU/QFXr9DercmPGDuxx8cP9+eOUVVwdZuhQaNICRI+HGG6Fx46jEbky0xU3iEJGpQH9gs6p29DveF3gcSAeeUdWxHq5VH3hEVYeVd54lDuNFaYvks7wCVn6/vdxzOxxdh/sHdTp0NJYq/Pe/rg7y+utuOfchQ1wdpHPnKEZvTOTFU+LoCewAni9NHCKSDqwGegP5wBJgCC6JPFzmEteo6mbf6x4Fpqvqp+W9pyUOE66cvAL+8NrykAkkq3Z1ujSvH3hI7zffuKG8U6e6LW9/8xtXBznnHKuDmIQQN4nDF0xL4E2/xPEr4F5V7eN7fCeAqpZNGqWvF2AsME9V3wtyzghgBEDz5s275uXlRfhTmFQwY/F6/rlkPT8U7uH77XvLPXdkz9aMObf9oU8UFLgi+oQJbq+Qdu1cC+SKK+Cww6IUuTGVF+8bOTUBNvg9zvcdC+Ym4CzgIhEZGegEVZ2sqt1UtVtWVlbkIjUpZWiP5vxr1Gl8cvdZDOpcfq1i0oJ1nPv4gkM3m6pfH+64A9atg+nTXdF85Ei3J8gf/wjffx/4gsYkiFglDglwLGjTR1UnqGpXVR2pqpOCXlRkgIhMLiwMvKKqMeEYP7gLI3u2Lvecr77bzoVPfcxpY99nxuL1Bz9ZrRoMHeqK5x99BKedBg8+CC1auNnoX3wRxeiNiZ5YJY58wH8p0qbApspeVFXnqOqIunXrVvZSxgAw5tz2vHL9KfTucCSNalcPel7+tj3c9drywC0QEejZ0xXPV61yuxLOmgUnnAC9e8M770BJSZQ/iTGRE6saRwauOH4msBFXHB+qql9W8n1sdVwTVTMWr+eu15aHPC9o/aPUTz+5zaWeeAI2bYL27V0d5PLLoWbNCEZsjHdxU+MQkZnAIqCdiOSLyDBVLQJGAXOBlcCsyiYNY6rC0B7NeeX6U2h/VPmbP01asI5ef/vw0NZHqQYNYMwYNyP9hRegRg23L0jz5nDPPfBD8OXjjYm1hJgAGC4bjmuqwozF65n44ZqQs9GPqFOd0We1K3+jKVVXBxk3DubMgerVXevj1luhY8fgrzMmguJqOG5Vs8RhqpLXOSAZaUL/448+dBZ6WatWufkg06bB7t1w9tluPsjZZ7t6iTFRkpKJw2ocJpbGvr2SSQvWeTrXUyvkxx/h6addHeT77+G441wL5LLLIDMzQlEbc0BEE4eIdFTVFRGJrApYi8PESk5eAbf9cxl5P+3ydP7Rh9fgycu6lr9L4d698M9/unWxvvgCsrLcmljXXw9HHBGhyI2JfOJYCFQHpgEzVHVbpSOMAmtxmHgxY/F6xs1bxdYd+zydH3AhxbJU4cMPXR3krbdcQf2KK1wrpEOHCERtUl3Eu6pEJBu4BrgY+B/wD1WdV6koo8RaHCZe5OQVMPadleTkFuBlpoanLiyAr7+G8ePhuedgzx7o29fVQc46y+ogpsKiUuPwLU44CJgA/IybAX6Xqr5a0UCjwRKHiUdj317JswvXsd9DBqlTI507z+0QOoFs3QqTJsGTT7ohvJ06uRbI0KGuRWJMGCLdVXU8cDVuT4x5wLOq+qmINAYWqWqLygYcCdZVZRLBjMXr+fOcL9lTFDqDVEsThp3WqvzJhODqIDNnum6s5cvhyCMP1EEaNYpQ5CbZRTpxLACmALNVdXeZ565Q1RcqHGkUWIvDJILRL33G68u8rbRTLV2477yOoVsgqvDee/DYY24pk8xMtzvh6NFw7LERiNoks0gnjtrAblUt9j1OAzJV1dvQkSpmicMkCq9zQEqJwMATPBTSAb76ytVBnn/etUj69XN1kDPOsDqICSjSieMT4CxV3eF7XBt4V1VPqXSkUWCJwySisW+vZMp/1lHssezYuWldXh91WugTN292dZCJE933J5zgEsjgwW6GujE+kU4cy1S1c6hj8cISh0lk4SYQT3NBwI2+mj7d1UG++gqOPhpGjYLrroOGDSsfuEl4kV7kcKeInOh38a7A7nLOjwnbj8MkgzHntuebh/vx0PmdyPDwL/S7n/dy4VMf0/vR+eWfmJkJw4bBihXw73+7EVh33w3NmsENN8Dq1RGJ3yQ/ry2Ok4CXOLBnxtHApaqaE8XYKsxaHCaZhNMCEeDB8zuFLqKXWrHCFdJffBH27YMBA1w31umnWx0kBUVjAmA1oB3ud/NrVd1fuRCjxxKHSUY5eQUMf24JP+0K/U9PgIFeZqOX+uEH+Pvf3dfWrdCli0sgl1xidZAUEo3EcQrQEsgoPaaqz1c0wGiyxGGSWU5eATe+mMP32/d6Oj89TRjuZS4IuNV4X3zR1UG+/hoaN4abbnJ7hTRoUMnITbyLdHH8BeAYYBlQ7DusqnpzpaKMEkscJlX0fnQ+a7bs9HRuz+xGPD+sh7cLl5TA3Lkugbz3Hhx2mNsn/ZZbIDu7EhGbeBbpxLES6KBxvga7zRw3qSgnr4CLn/rY01pYAlwXalvbsr74wtVBpk+HoiI47zzXjfXrX1sdJMlEOnG8DNysqt9FIrhosxaHSUWDnlzIsnxvIwrDLqIDfPedq4E89ZTbK6RrV5dALr4YqlWrWNAmrkQ6cXwIdMativtLx6qqnleZIKPFEodJZWPfXsnTC9bhpXugQglk1y63T/pjj7ndCps0gZtvhuHDoX6IuSQmrkU6cZwe6LiqflSB2KLOEocxTtu732afh3G89WpmsOyePuFdvKTErYc1bhx88AHUqgXXXOPqIMccU8GITSxFdAKgL0HkAtV83y8BPq1UhMaYqFv94LlkZ9UKed623UW0HPNW6EmE/tLS3PpX778Pn30GF17oljbJzoYLLoCFC92iiybpeEocIjIcmA087TvUBHg9WkEZYyJn3u29yB3bj85N64Y8d82WnRxz51vhv0nnzm5TqdxcuPNOmD/fFc979ICXXoL9cTvty1SA1yVHbgROxW3ehKquAWyzY2MSyOujTiN3bD+a1sss97xiJfzWR6nGjeHBB2HDBldI37YNhgxbRS9OAAAVSklEQVRxXVePPOIem4TnNXHsVdVfNk8WkQzwVHurNBFpLyKTRGS2iFxfFe9pTDJbOOZMcsf2o2aIhbDWbNlJyzFv0frOt8jJKwjvTWrVcptIff01vPGGSxx33OHWxRo9Gr79thKfwMSa18TxkYjcBdQUkd7Ay8CcUC8SkakisllEVpQ53ldEVonIWhEZU941VHWlqo4ELgFCFm2MMd6sfOAcRvZsHfK8EoULn/qYlmPe4rfPLg7vTdLS3PpXH34IOTkwaJBb3r1NGzeMd9GiCkZvYsnrqKo0YBhwNm4E31zgmVATAkWkJ7ADeF5VO/qOpQOrgd5APq7QPgRIBx4uc4lrVHWziJwHjAGeVNUZoeK1UVXGhOekB+axZce+0Cf65I7tV/E327jR7ZE+aZLruurRw80HueACyMgI/XoTNRFfq6oSgbQE3vRLHL8C7lXVPr7HdwKoatmkEehab6lqwN9YERkBjABo3rx517y8vIjEb0yqCGcrW4BB4SyiGMiOHTBtmtul8JtvoEULNx9k2DCoG7qQbyIvosNxReRbEVlX9quCsTUBNvg9zvcdC/bevURkgog8Dbwd7DxVnayq3VS1W1ZWVgVDMyZ1jR/cxfPoK4DXl22q2AisUrVru42kVq2C116D5s3h9ttdHeS228D+8xe3vHZV+W8PlglcDDRQ1T95eG1LDm5xXAz0UdVrfY+vALqr6k1hR3/oe9laVcZEkNcJhNlZtZh3e6/Kv+GSJW5G+qxZbg7IRRe5JNLD4+KMplIiPQHwR7+vjao6HvhNBWPLB5r5PW7KgQ2ijDFxZPWD54Y1Aivs4nlZJ50EM2a4UVe33+5W6D35ZDj1VHjlFSguDn0NE3Veu6pO9PvqJiIjgToVfM8lQLaItBKR6sBg4I0KXusgqjpHVUfUtf5RYyJq5QPn8ND5nUKet2DNVlqOqUT3ValmzeCvf3XzQSZMgO+/d62P7Gx4/HHYvr3y72EqLJxFDksV4ZYfeURVV4V43UygF9AI+AG4R1WfFZFzgfG4kVRTVfXBCkV/6PtZV5UxURZOYnjl+lPo2iICCx8WF8O//uXWxfrvf+Hww93mUjfd5GojJiLiZlRVLNhwXGOiK5wl3COWPEotXuzqILNnu8cXX+zqICedFLn3SFGRXh33tvKeV9VxYcQWdZY4jKkaHf/0b3bsC113aFovk4Vjzozsm+flwRNPwJQp8PPPcNppLoGcdx6kp0f2vVJEpBPHDOAkDtQiBgAL8A2rVdX7Kh5q5FhXlTGx0XrMW552IIRKTh4M5OefYepUV/vIzYXWrd2yJldf7Yb8Gs8inTjeBS5U1e2+x3WAl1W1b6UjjQJrcRhT9XLyCrjwqY89nRvW/udeFRXB66+7OsiiRW4S4XXXuTpI06aRfa8kFenE8TVwgqru9T2uAXyuqsdWOtIIshaHMfHBawE94q2PUosWuTrIK6+49bIuucR1Y3XtGp33SxKRThx34xYZfA23Ku75wCxVfaiygUaDtTiMiT2vySNikwcDyc11w3mfecYN4e3Z0yWQ/v2tDhJApCcAPghcDRQA24Cr4zVpGGPiQ+7YfqRL6PNKJw9GRcuWrutqwwZ49FGXSAYNgmOPdav07twZnfdNcl6XVQc4DPhZVR8H8kWkVZRiqjARGSAikwsLvQ0TNMZE1zcP9yN3bD96ZjcKeW5EZp4HU7eua2l88w3885/QoIFbJ6tZM7dj4caN0XnfJOW1q+oe3F4Y7VS1rYg0xhXHT412gBVhXVXGxCevLYuHzu/E0B5RnNin6uog48a5BRbT0mDwYJdculRixd8EF9GuKlxN4zxgJ4CqbqLiS44YY1JU7th+njaPuuu15bT/wzvRC0QETjnFTSJcswZuvNGNyDrxRDjjDJgzB0q8DjBOPV4Txz7fpk0KICK1oheSMSaZjTm3vafRVLuLSqJX+/DXurXbE2TDBvjb32DtWjeJsH17eOop2LUr+jEkGK+JY5ZvP4x6IjIceA+YEr2wjDHJLndsP+rVDL3jX8sxbzH27ZXRD6hePfjd72DdOpg5062HdcMNrg5y993w3XfRjyFBeF6ryrfX+C9bx6rqvGgGVhE2j8OYxBTzeR+BqMLChW4+yOuvu21thw6FW2+FE06oujiqUMTmcfj2CJ+rqmdFKrhos+K4MYnJSwKp0uRRau1aNx9k6lQ3hPfMM10hvW9fV1hPEhErjqtqMbBLRGyTC2NMVHlJClEdthtMmzYucWzYAH/5C3z9NfTrB8cdB5Mnw+7dVRtPjHlNlXuA5SLyrG//7wkiMiGagRljUlPu2H4hN42K2IZR4apfH/7v/9wOhS++CIcd5tbDatYM/vQnt+FUCvA6j+PKQMdV9bmIRxQB1lVlTHLwkhzq1cxg2T19qiCaAFRhwQI3H2TOHKhWDS67zNVBOoXeMTHeRKTGISLNVXV9RCOLIiuOG5N84rJwHsjq1W5p93/8w3Vd9e7t6iB9+rh5IwkgUjWO1/0u+Eqlo4oy23PcmOSTO7YfnZuG/jfdcsxbtL377SqIKIi2bd36V/n58NBDsGIFnHMOdOzoFllMojpIqMThnyZDT/c0xpgoeH3UaZ5aFPuKNTa1D38NGrj1r3Jz4fnnoXp1GD4cWrSAe++FzZtjG18EhEocGuR7Y4ypcl6XLIl58gCXMK64Aj79FD74AHr0gPvug+bN4dpr4csvYx1hhYWqcRTj1qcSoCZQOvdeAFXVw6MeYQVYcdyY5OclOQzq3Jjxg+No0cJVq9zyJs8957qu+vRxdZDeveOiDhKRGoeqpqvq4apaR1UzfN+XPo7LpGGMSQ1elix5fdkmTnogjha5aNfOrX+1fj088AB8/rlLHp06ucmFe/bEOkJPkmfKozEm5Sy7p0/I2seWHftiWzQPpFEjt/5Vbi5Mm+Z2Ixw2zNVB/vxn2LIl1hGWKyESh4jUEpEcEekf61iMMfEnVPKIi6J5IDVqwJVXwrJl8N570K0b3HOPq4OMGAErq2BxxwqIauIQkakisllEVpQ53ldEVonIWhEZ4+FSvwdmRSdKY0wy8NJ1FZfJA1x948wz4a234Kuv4Le/hRdegA4d4NxzXVLxuCBtVfC8Om6FLi7SE9gBPK+qHX3H0oHVQG8gH1gCDAHSgYfLXOIa4HigEZAJbFXVN0O9rxXHjUltoRJEzCcLerFlC0yaBE8+6YbwdurkCulDhriWShREegfAClHVBcBPZQ53B9aq6jpV3Qe8BAxU1eWq2r/M12bgDOBkYCgwXEQCxiwiI0RkqYgs3RLn/YPGmOgKlRjituXhLysL/vhHyMtzhXNVuPpqVwd54AHYujVmocWixtEE2OD3ON93LCBVvVtVRwMzgCmqGnA/R1WdrKrdVLVbVlZWRAM2xiSepEgeAJmZLmF88QW8+67bE/2Pf3QLK44c6VbqrWKxSByBBiuH7C9T1WmhuqlEZICITC4sLKxwcMaY5JE0yQNcHaR3b3jnHbecyeWXuxFZ7dvDgAFukmEV1UFikTjygWZ+j5sCm2IQhzEmBXhJHjl5BVUUTYQcdxxMmeLmg9x7Lyxe7IrrXbpAFdR3Y5E4lgDZItJKRKoDg4E3InFhW+TQGBNIqORx4VMfJ1bro9QRR7jhu+vXu4UUAY48MupvG+3huDOBRUA7EckXkWGqWgSMAuYCK4FZqhqRRVusq8oYE4zX3QUTUmamm0C4bJmrfURZVIfjxooNxzXGBNP27rfZV1z+372EGK4bBXExHNcYY+LN6gfP5ZXrTyn3nIRteVSRpEoc1lVljPGia4v6yTXiqoolVeKw4rgxJhyWPComqRKHtTiMMeGy5BG+pEoc1uIwxlSEJY/wJFXiMMaYirLk4V1SJQ7rqjLGVIYlD2+SKnFYV5UxprIseYSWVInDGGMiwZJH+SxxGGNMAJY8gkuqxGE1DmNMJFnyCCypEofVOIwxkWbJ41BJlTiMMSYaLHkczBKHMcZ4YMnjAEscxhjjUaout16WJQ5jjAlDeckjVVodSZU4bFSVMaYqpHrySKrEYaOqjDHxINmTR1IlDmOMqSqpXCy3xGGMMRWUqsnDEocxxlRCKiYPSxzGGFNJqZY8LHEYY0wEpNIcj7hPHCLSS0T+IyKTRKRXrOMxxphgykseJz0wrwojia6oJg4RmSoim0VkRZnjfUVklYisFZExIS6jwA4gE8iPVqzGGBMJwZLHlh37qjiS6Il2i2Ma0Nf/gIikAxOBc4AOwBAR6SAinUTkzTJfRwD/UdVzgN8D90U5XmOMiZpkqXVENXGo6gLgpzKHuwNrVXWdqu4DXgIGqupyVe1f5muzqpb4XlcA1Aj2XiIyQkSWisjSLVu2ROXzGGOMF8le74hFjaMJsMHvcb7vWEAicoGIPA28ADwZ7DxVnayq3VS1W1ZWVsSCNcaYihjUuXHA48nQ6ohF4pAAxzTYyar6qqpep6qXqur8ci9sa1UZY+LE+MFdgj6X6MkjFokjH2jm97gpsCkGcRhjTMwkcvKIReJYAmSLSCsRqQ4MBt6IxIVtkUNjTDxJ1omB0R6OOxNYBLQTkXwRGaaqRcAoYC6wEpilql9G6P2sq8oYE1eSsVAuqkHLCwmrW7duunTp0liHYYwxQOiWRbwkFxHJUdVuoc6L+5nj4bAWhzEmHsVLYoiUpEocVuMwxsSrZNo1MKkShzHGxLNkSR5JlTisq8oYY6IvqRKHdVUZYxLZoCcXxjoET5IqcRhjTLwrr7tqWX5hQiSPpEoc1lVljEkE5SWPFZt+rsJIKiapEod1VRljEl3HxofHOoSQkipxGGNMogjW6liWXxj3I6wscRhjTIwk6vDcpEocVuMwxpjoS6rEYTUOY4yJvqRKHMYYk2iCdVfF8/pWGbEOwBhjUl1pkjh17Af86piGPHLxCTGOqHyWOIwxJk5s3Lab2Tn5zM7JP+h4vLU+rKvKGGPiQHmjqOJthFVSJQ4bVWWMMdGXVInDRlUZY0z0JVXiMMaYRFVeHSPeahxWHDfGmDhRmiAKdu6jy/3zuHdAB646tVWMozqUtTiMMSbOpIkAUKwxDiQISxzGGBNn0nx/mUtK4jNzWOIwxpg4k55W2uKIz8QR9zUOEUkD7gcOB5aq6nMxDskYY6KqtKuqJBUTh4hMBfoDm1W1o9/xvsDjQDrwjKqOLecyA4EmwE9AfjnnGWNMUihtcfz136v4679XHfJ8rEdZRburahrQ1/+AiKQDE4FzgA7AEBHpICKdROTNMl9HAO2ARap6G3B9lOM1xpiYy777nXKfj/VM8qi2OFR1gYi0LHO4O7BWVdcBiMhLwEBVfRjXOjmIiOQD+3wPi4O9l4iMAEYANG/evNKxG2OMCSwWxfEmwAa/x/m+Y8G8CvQRkSeABcFOUtXJqtpNVbtlZWVFJlJjjDGHiEXikADHglaAVHWXqg5T1ZtUdWK5F7a1qowxSSBUDSPWNY5YjKrKB5r5PW4KbIpBHMYYE7dinRzKE4sWxxIgW0RaiUh1YDDwRiQubIscGmNM9EU1cYjITGAR0E5E8kVkmKoWAaOAucBKYJaqfhmh97OuKmOMiTLROJ1gUhndunXTpUuXxjoMY4xJKCKSo6rdQp2XVEuOWIvDGGOiL6kSh9U4jDEm+pIqcRhjjIm+uF/kMBwiMgAYAPwsImv8nqoLFHp83AjYGoXwyr5nJF9T3nnBngt03O6Tt+N2n7wdt/vk7Xg83acWns5W1aT/AiZ7fYxbgTfqMUTyNeWdF+y5QMftPtl9svtk98nLV6p0Vc0J83FVxBDJ15R3XrDnAh23++TtuN0nb8ftPnk7nnD3KSmH41aGiCxVD8PRUp3dJ2/sPnlj98mbeLlPqdLiCMfkWAeQIOw+eWP3yRu7T97ExX2yFocxxpiwWIvDGGNMWCxxGGOMCYslDmOMMWGxxBGCiNQSkedEZIqIXBbreOKViLQWkWdFZHasY4lnIjLI97v0LxE5O9bxxCsRaS8ik0RktohcH+t44pnvb1SOiByy9Xa0pGTiEJGpIrJZRFaUOd5XRFaJyFoRGeM7fAEwW1WHA+dVebAxFM59UtV1qjosNpHGVpj36XXf79JVwKUxCDdmwrxPK1V1JHAJEPPhp1UpzL9PAL8HZlVljCmZOIBpQF//AyKSDkwEzgE6AENEpANuh8LSPdKLqzDGeDAN7/cplU0j/Pv0B9/zqWQaYdwnETkPWAi8X7Vhxtw0PN4nETkL+Ar4oSoDTMnEoaoLgJ/KHO4OrPX9z3kf8BIwELfVbVPfOSl1v8K8TykrnPskzl+Ad1T106qONZbC/X1S1TdU9RQgpbqIw7xPZwAnA0OB4SJSJX+jkmqRw0pqwoGWBbiE0QOYADwpIv2omqn/8S7gfRKRhsCDQBcRuVNVH45JdPEj2O/TTcBZQF0RaaOqk2IRXBwJ9vvUC9dNXAN4OwZxxZuA90lVRwGIyFXAVlUtqYpgLHEcIAGOqaruBK6u6mDiWLD79CMwsqqDiWPB7tME3H9GjBPsPs0H5ldtKHEt4H365RvVaVUXSop1vYSQDzTze9wU2BSjWOKZ3Sdv7D55Y/fJm7i6T5Y4DlgCZItIKxGpDgwG3ohxTPHI7pM3dp+8sfvkTVzdp5RMHCIyE1gEtBORfBEZpqpFwChgLrASmKWqX8Yyzliz++SN3Sdv7D55kwj3yRY5NMYYE5aUbHEYY4ypOEscxhhjwmKJwxhjTFgscRhjjAmLJQ5jjDFhscRhjDEmLJY4jKkkESkWkWUiskJE5ohIvUpca76IpNQy4ibxWOIwpvJ2q2pnVe2IW9X0xlgHZEw0WeIwJrIW4VYyRURqi8j7IvKpiCwXkYG+4y1FZKVvJ8AvReRdEanpfxERSfPtPPlADD6DMeWyxGFMhPg22zmTA2sI7QHOV9UTcfsmPCoipaucZgMTVfU4YBtwod+lMoDpwGpV/UOVBG9MGCxxGFN5NUVkGfAj0ACY5zsuwEMi8gXwHq4lcqTvuW9VdZnv+xygpd/1ngZWqOqD0Q7cmIqwxGFM5e1W1c5AC6A6B2oclwFZQFff8z8Amb7n9vq9vpiD98b5GDhDRDIxJg5Z4jAmQlS1ELgZ+J2IVAPqAptVdb+InIFLLF48i9v17mURsc3WTNyxxGFMBKnqZ8DnuP0SpgPdRGQprvXxdRjXGQd8CrxQVftIG+OVLatujDEmLPY/GWOMMWGxxGGMMSYsljiMMcaExRKHMcaYsFjiMMYYExZLHMYYY8JiicMYY0xYLHEYY4wJy/8DXkrdMm/9Lg4AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Lexical distribution\n", - "te = upcfg.terminal_expectations()\n", - "probs = [ te[a] for a in te]\n", + "# sampled lexical distribution\n", + "n_samples = 1000000\n", + "lc = Counter()\n", + "for _ in range(n_samples):\n", + " s = sampler.sample_string()\n", + " for a in s:\n", + " lc[a] += 1\n", + "probs = [lc[a]/n_samples for a in lc]\n", + "\n", "probs.sort(key = lambda x : -x)\n", "ranks = np.arange(1, len(probs)+1)\n", "plt.plot(ranks, probs, rasterized=True,marker=\".\")\n", + "n = len(te)\n", + "plt.plot([1,n],[1,1/n],'r')\n", "plt.yscale('log')\n", "plt.xscale('log')\n", "plt.xlabel('Rank')\n", @@ -229,27 +520,55 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "0.11850898717289121" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "max(te.values())/upcfg.expected_length()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "H(tree|string)= 0.35069371712577607\n" + ] + } + ], "source": [ "# ambiguity: H(tree|string)\n", - "print(\"H(tree|string)=\",upcfg.estimate_ambiguity(samples=1000))" + "print(\"H(tree|string)=\",upcfg.estimate_ambiguity(samples=1000,sampler=sampler))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "# ambiguity ; derivations per string.\n", - "sampler = pcfg.Sampler(upcfg)\n", + "#sampler = pcfg.Sampler(upcfg)\n", "counter = inside.InsideComputation(upcfg)\n", "derivations = Counter()\n", "strings = Counter()\n", - "max_length = 30\n", - "n_samples = int(1e4)\n", + "max_length = 20\n", + "n_samples = int(1e3)\n", "for i in range(n_samples):\n", " s = utility.collect_yield(sampler.sample_tree())\n", " l = len(s)\n", @@ -261,9 +580,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0,0.5,'Mean derivations per string')" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "x = [list(strings)][0]\n", "x.sort()\n", @@ -275,47 +615,48 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "#communicability\n", - "n_samples = 10000\n", - "same = 0.0\n", - "insider = inside.InsideComputation(upcfg)\n", - "for i in range(n_samples):\n", - " t = sampler.sample_tree()\n", - " s =utility.collect_yield(t)\n", - " mapt = insider.viterbi_parse(s)\n", - " if t == mapt:\n", - " same += 1\n", - "print(\"Communicability is %f\"% (same/n_samples))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import em\n", - "reload(em)\n", - "reload(inside)\n", - "reload(pcfg)\n", - "trainer = em.Trainer(None)\n", - "n_samples = 10000\n", - "trainer.training = [ utility.collect_yield(sampler.sample_tree()) for _ in range(n_samples)]" + "Communicabiity is a measure of the ambiguity of a grammar; if it is 1 then the grammar is unaambiguous.\n", + "It is the probability of successful communication between two optimal agents both equipped with the same grammar.\n", + "The first samples a tree ($t_0$) from the distribution and transmits the yield ($s$) to the other who computes the most likely tree given that string $t_1$. If $t_0 = t_1$ then communication is successful.\n", + "We estimate this using Monte Carlo methods.\n", + "\n", + "$$\\sum_{\\tau} P(\\tau) \\mathbb{I}( \\tau = viterbi(y(\\tau))) \\approx \\sum_i \\frac{1}{N} \\mathbb{I}( \\tau_i = viterbi(y(\\tau_i)))$$\n", + "\n", + "OR\n", + "\n", + "$$\\sum_{w} P(w) \\frac{P(viterbi(w))}{P(w)} \\approx \\sum_i \\frac{1}{N} \\frac{P(viterbi(w))}{P(w)}$$" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2.21 s, sys: 8.39 ms, total: 2.22 s\n", + "Wall time: 2.22 s\n" + ] + }, + { + "data": { + "text/plain": [ + "(0.894, 0.8924940240323588)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "trainer.max_length = 5\n", - "tpcfg,lps = trainer.train(upcfg)" + "%%time\n", + "upcfg.estimate_communicability(sampler=sampler)" ] }, {