diff --git a/.gitignore b/.gitignore index 7778ca96e..edddd4fbc 100644 --- a/.gitignore +++ b/.gitignore @@ -173,6 +173,8 @@ examples/example3_systematics/data examples/example3_systematics/mg_processes examples/example3_systematics/models +examples/example4_tth + # MG / Pythia / Delphes patch patches/ diff --git a/docs/conf.py b/docs/conf.py index ea48983e8..ae2cfbfbc 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -24,7 +24,7 @@ author = 'Johann Brehmer, Felix Kling, Irina Espejo, and Kyle Cranmer' # The short X.Y version -version = '0.2.8' +version = '0.3.0' # The full version, including alpha/beta/rc tags release = version diff --git a/examples/tutorial_delphes/1_from_cards_to_likelihood_ratio.ipynb b/examples/tutorial_delphes/1_from_cards_to_likelihood_ratio.ipynb index 3593d5a5f..ccd81d11e 100755 --- a/examples/tutorial_delphes/1_from_cards_to_likelihood_ratio.ipynb +++ b/examples/tutorial_delphes/1_from_cards_to_likelihood_ratio.ipynb @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -49,11 +49,11 @@ "%matplotlib inline\n", "\n", "from madminer.core import MadMiner\n", - "from madminer.delphes import DelphesProcessor\n", + "from madminer.delphes import DelphesReader\n", "from madminer.sampling import combine_and_shuffle\n", "from madminer.sampling import SampleAugmenter\n", - "from madminer.sampling import constant_benchmark_theta, multiple_benchmark_thetas, random_morphing_thetas\n", - "from madminer.ml import MLForge\n", + "from madminer import sampling\n", + "from madminer.ml import ParameterizedRatioEstimator\n", "from madminer.plotting import plot_2d_morphing_basis, plot_distributions\n" ] }, @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -82,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -135,15 +135,15 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "15:15 madminer.core INFO Added parameter CWL2 (LHA: dim6 2, maximal power in squared ME: (2,), range: (-10.0, 10.0))\n", - "15:15 madminer.core INFO Added parameter CPWL2 (LHA: dim6 5, maximal power in squared ME: (2,), range: (-10.0, 10.0))\n" + "14:38 madminer.core INFO Added parameter CWL2 (LHA: dim6 2, maximal power in squared ME: (2,), range: (-10.0, 10.0))\n", + "14:38 madminer.core INFO Added parameter CPWL2 (LHA: dim6 5, maximal power in squared ME: (2,), range: (-10.0, 10.0))\n" ] } ], @@ -198,15 +198,15 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "15:15 madminer.core INFO Added benchmark sm: CWL2 = 0.00e+00, CPWL2 = 0.00e+00)\n", - "15:15 madminer.core INFO Added benchmark w: CWL2 = 10.00, CPWL2 = 0.00e+00)\n" + "14:38 madminer.core INFO Added benchmark sm: CWL2 = 0.00e+00, CPWL2 = 0.00e+00)\n", + "14:38 madminer.core INFO Added benchmark w: CWL2 = 10.00, CPWL2 = 0.00e+00)\n" ] } ], @@ -239,7 +239,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": { "scrolled": true }, @@ -248,13 +248,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "15:15 madminer.core INFO Optimizing basis for morphing\n", - "15:15 madminer.core INFO Added benchmark sm: CWL2 = 0.00e+00, CPWL2 = 0.00e+00)\n", - "15:15 madminer.core INFO Added benchmark w: CWL2 = 10.00, CPWL2 = 0.00e+00)\n", - "15:15 madminer.core INFO Added benchmark morphing_basis_vector_2: CWL2 = -6.60e+00, CPWL2 = -9.63e+00)\n", - "15:15 madminer.core INFO Added benchmark morphing_basis_vector_3: CWL2 = 1.07, CPWL2 = -6.54e+00)\n", - "15:15 madminer.core INFO Added benchmark morphing_basis_vector_4: CWL2 = -4.67e+00, CPWL2 = 8.95)\n", - "15:15 madminer.core INFO Added benchmark morphing_basis_vector_5: CWL2 = -9.59e+00, CPWL2 = -6.15e-01)\n" + "14:38 madminer.core INFO Optimizing basis for morphing\n", + "14:38 madminer.core INFO Set up morphing with 2 parameters, 6 morphing components, 2 predefined basis points, and 4 new basis points\n" ] } ], @@ -470,11 +465,11 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "dp = DelphesProcessor('data/madminer_example.h5')" + "delphes = DelphesReader('data/madminer_example.h5')" ] }, { @@ -502,14 +497,14 @@ } ], "source": [ - "dp.add_sample(\n", + "delphes.add_sample(\n", " lhe_filename='mg_processes/signal/Events/run_01/unweighted_events.lhe.gz',\n", " hepmc_filename='mg_processes/signal/Events/run_01/tag_1_pythia8_events.hepmc.gz',\n", " sampled_from_benchmark='sm',\n", " is_background=False,\n", ")\n", "\"\"\"\n", - "dp.add_sample(\n", + "delphes.add_sample(\n", " lhe_filename='mg_processes/background/Events/run_01/unweighted_events.lhe.gz',\n", " hepmc_filename='mg_processes/background/Events/run_01/tag_1_pythia8_events.hepmc.gz',\n", " sampled_from_benchmark='sm',\n", @@ -517,7 +512,7 @@ ")\n", "\"\"\"\n", "\n", - "dp.run_delphes(\n", + "delphes.run_delphes(\n", " delphes_directory=mg_dir + '/Delphes',\n", " delphes_card='cards/delphes_card.dat',\n", " log_file='logs/delphes.log',\n", @@ -542,13 +537,13 @@ "metadata": {}, "outputs": [], "source": [ - "dp.add_observable(\n", + "delphes.add_observable(\n", " 'pt_j1',\n", " 'j[0].pt',\n", " required=False,\n", " default=0.,\n", ")\n", - "dp.add_observable(\n", + "delphes.add_observable(\n", " 'delta_phi_jj',\n", " 'j[0].deltaphi(j[1]) * (-1. + 2.*float(j[0].eta > j[1].eta))',\n", " required=True,\n", @@ -568,7 +563,7 @@ "metadata": {}, "outputs": [], "source": [ - "dp.add_cut('pt_j1 > 30.')" + "delphes.add_cut('pt_j1 > 30.')" ] }, { @@ -595,7 +590,7 @@ } ], "source": [ - "dp.analyse_delphes_samples()" + "delphes.analyse_delphes_samples()" ] }, { @@ -611,7 +606,7 @@ "metadata": {}, "outputs": [], "source": [ - "dp.save('data/madminer_example_with_data.h5')" + "delphes.save('data/madminer_example_with_data.h5')" ] }, { @@ -734,25 +729,25 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "16:34 madminer.sampling INFO Loading data from data/madminer_example_shuffled.h5\n", - "16:34 madminer.sampling INFO Found 2 parameters\n", - "16:34 madminer.sampling INFO Did not find nuisance parameters\n", - "16:34 madminer.sampling INFO Found 6 benchmarks, of which 6 physical\n", - "16:34 madminer.sampling INFO Found 2 observables\n", - "16:34 madminer.sampling INFO Found 46046 events\n", - "16:34 madminer.sampling INFO Found morphing setup with 6 components\n" + "14:39 madminer.sampling INFO Loading data from data/madminer_example_shuffled.h5\n", + "14:39 madminer.sampling INFO Found 2 parameters\n", + "14:39 madminer.sampling INFO Did not find nuisance parameters\n", + "14:39 madminer.sampling INFO Found 6 benchmarks, of which 6 physical\n", + "14:39 madminer.sampling INFO Found 2 observables\n", + "14:39 madminer.sampling INFO Found 46046 events\n", + "14:39 madminer.sampling INFO Found morphing setup with 6 components\n" ] } ], "source": [ - "sa = SampleAugmenter('data/madminer_example_shuffled.h5')" + "sampler = SampleAugmenter('data/madminer_example_shuffled.h5')" ] }, { @@ -760,39 +755,41 @@ "metadata": {}, "source": [ "The `SampleAugmenter` class defines five different high-level functions to generate train or test samples:\n", - "- `extract_samples_train_plain()`, which only saves observations x, for instance for histograms or ABC;\n", - "- `extract_samples_train_local()` for methods like SALLY and SALLINO, which will be demonstrated in the second part of the tutorial;\n", - "- `extract_samples_train_ratio()` for techniques like CARL, ROLR, CASCAL, and RASCAL, when only theta0 is parameterized;\n", - "- `extract_samples_train_more_ratios()` for the same techniques, but with both theta0 and theta1 parameterized;\n", - "- `extract_samples_test()` for the evaluation of any method.\n", + "- `sample_train_plain()`, which only saves observations x, for instance for histograms or ABC;\n", + "- `sample_train_local()` for methods like SALLY and SALLINO, which will be demonstrated in the second part of the tutorial;\n", + "- `sample_train_density()` for neural density estimation techniques like MAF or SCANDAL;\n", + "- `sample_train_ratio()` for techniques like CARL, ROLR, CASCAL, and RASCAL, when only theta0 is parameterized;\n", + "- `sample_train_more_ratios()` for the same techniques, but with both theta0 and theta1 parameterized;\n", + "- `sample_test()` for the evaluation of any method.\n", "\n", - "For the arguments `theta`, `theta0`, or `theta1`, you can (and should!) use the helper functions `constant_benchmark_theta()`, `multiple_benchmark_thetas()`, `constant_morphing_theta()`, `multiple_morphing_thetas()`, and `random_morphing_thetas()`, all defined in the `madminer.sampling` module.\n", + "For the arguments `theta`, `theta0`, or `theta1`, you can (and should!) use the helper functions `benchmark()`, `benchmarks()`, `morphing_point()`, `morphing_points()`, and `random_morphing_points()`, all defined in the `madminer.sampling` module.\n", "\n", "Here we'll train a likelihood ratio estimator with the ALICES method, so we focus on the `extract_samples_train_ratio()` function." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "16:34 madminer.sampling INFO Extracting training sample for ratio-based methods. Numerator hypothesis: (u'random', (100, [(u'gaussian', 0.0, 10.0), (u'gaussian', 0.0, 10.0)])), denominator hypothesis: (u'benchmark', u'sm')\n", - "16:34 madminer.sampling WARNING Large statistical uncertainty on the total cross section for theta = [-7.92202596 3.87210373]: (0.010395 +/- 0.001749) pb. Skipping these warnings in the future...\n", - "16:34 madminer.sampling WARNING For this value of theta, 1 / 23023 events have negative weight and will be ignored\n", - "16:34 madminer.sampling INFO Effective number of samples: mean 15.124643599114712, with individual thetas ranging from 5.939722567101945 to 60.460140446976716\n", - "16:34 madminer.sampling INFO Effective number of samples: mean 23023.000000006065, with individual thetas ranging from 23023.000000006068 to 23023.000000006068\n" + "14:40 madminer.sampling INFO Extracting training sample for ratio-based methods. Numerator hypothesis: (u'random', (100, [(u'gaussian', 0.0, 15.0), (u'gaussian', 0.0, 15.0)])), denominator hypothesis: (u'benchmark', u'sm')\n", + "14:40 madminer.sampling WARNING Large statistical uncertainty on the total cross section for theta = [ 15.57780154 -11.11415019]: (0.055290 +/- 0.006370) pb. Skipping these warnings in the future...\n", + "14:40 madminer.sampling WARNING For this value of theta, 1 / 36837 events have negative weight and will be ignored\n", + "14:40 madminer.sampling WARNING For this value of theta, 1 / 36837 events have negative weight and will be ignored\n", + "14:40 madminer.sampling INFO Effective number of samples: mean 28.67984811442441, with individual thetas ranging from 9.082242574348482 to 1089.7962485221415\n", + "14:40 madminer.sampling INFO Effective number of samples: mean 36837.00000001676, with individual thetas ranging from 36837.00000001676 to 36837.00000001676\n" ] } ], "source": [ - "x, theta0, theta1, y, r_xz, t_xz = sa.extract_samples_train_ratio(\n", - " theta0=random_morphing_thetas(100, [('gaussian', 0., 10.), ('gaussian', 0., 10.)]),\n", - " theta1=constant_benchmark_theta('sm'),\n", - " n_samples=25000,\n", + "x, theta0, theta1, y, r_xz, t_xz, _ = sampler.sample_train_ratio(\n", + " theta0=sampling.random_morphing_points(100, [('gaussian', 0., 15.), ('gaussian', 0., 15.)]),\n", + " theta1=sampling.benchmark('sm'),\n", + " n_samples=100000,\n", " folder='./data/samples',\n", " filename='train'\n", ")" @@ -802,12 +799,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For the evaluation we'll need a test sample, and we'll make two just for fun:" + "For the evaluation we'll need a test sample:" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 12, "metadata": { "scrolled": true }, @@ -816,15 +813,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "16:34 madminer.sampling INFO Extracting evaluation sample. Sampling according to (u'benchmark', u'sm')\n", - "16:34 madminer.sampling INFO Effective number of samples: 23022.000000006065\n" + "14:41 madminer.sampling INFO Extracting evaluation sample. Sampling according to (u'benchmark', u'sm')\n", + "14:41 madminer.sampling INFO Effective number of samples: 9207.999999998738\n" ] } ], "source": [ - "_ = sa.extract_samples_test(\n", - " theta=constant_benchmark_theta('sm'),\n", - " n_samples=25000,\n", + "_ = sampler.sample_test(\n", + " theta=sampling.benchmark('sm'),\n", + " n_samples=1000,\n", " folder='./data/samples',\n", " filename='test'\n", ")" @@ -846,36 +843,36 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "16:34 madminer.sampling INFO Starting cross-section calculation\n", - "16:34 madminer.sampling INFO Starting cross-section calculation\n" + "14:41 madminer.sampling INFO Starting cross-section calculation\n", + "14:41 madminer.sampling INFO Starting cross-section calculation\n" ] } ], "source": [ - "thetas_benchmarks, xsecs_benchmarks, xsec_errors_benchmarks = sa.extract_cross_sections(\n", - " theta=multiple_benchmark_thetas(['sm', 'w', 'morphing_basis_vector_2', 'morphing_basis_vector_3', 'morphing_basis_vector_4', 'morphing_basis_vector_5'])\n", + "thetas_benchmarks, xsecs_benchmarks, xsec_errors_benchmarks = sampler.cross_sections(\n", + " theta=sampling.benchmarks(['sm', 'w', 'morphing_basis_vector_2', 'morphing_basis_vector_3', 'morphing_basis_vector_4', 'morphing_basis_vector_5'])\n", ")\n", "\n", - "thetas_morphing, xsecs_morphing, xsec_errors_morphing = sa.extract_cross_sections(\n", - " theta=random_morphing_thetas(1000, [('gaussian', 0., 4.), ('gaussian', 0., 4.)])\n", + "thetas_morphing, xsecs_morphing, xsec_errors_morphing = sampler.cross_sections(\n", + " theta=sampling.random_morphing_points(1000, [('gaussian', 0., 4.), ('gaussian', 0., 4.)])\n", ")" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWIAAAEYCAYAAABm5fzdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsnXecXHW1wL/n3qlbk91NWdJDQoAECOmABAENVRBEimAjyhPre+p7iqjPxnu2pyJSRAGlSROkhg5CJEAaCemF9LKb7WXaLef9cWdnZ3ZmN7PJps+XzyUz9/5+v/u7d2fOnHt+p4iqUqBAgQIFDhzGgZ5AgQIFChzpFARxgQIFChxgCoK4QIECBQ4wBUFcoECBAgeYgiAuUKBAgQNMQRAXKFCgwAGmTwSxiNwtIrUisixtX4WIvCQia5P/9u+m72eTbdaKyGf7Yj4FChQocCjRVxrxX4Bzu+z7LvCKqo4FXkm+z0BEKoD/BqYD04D/7k5gFyhQoMDhSp8IYlV9A2josvti4K/J138FPp6j6znAS6raoKqNwEtkC/QCBQoUOKzx7cOxB6nqDgBV3SEiA3O0GQJsSXu/NbkvCxG5DrgOoLi4ePKxxx675zPTCDg1oDEQHxgDwOiXo10UtA0wwCin726X7c0BE6QIkD4at4/QBLh1yfsTAKMKJNR53FoO5IrINMA3MnlNeZxG40ACwQB7Y44xDTAHgVG5J1dRoA9YuHBhnaoO6G2/c84s1voGJ//zLI2/oKo9KmEici5wM2ACf1bVn3c5HgTuBSYD9cAVqrpRRD4K/BwIAAngP1X11WSfyXhP9GHgOeAbegDCjfelIM6HXBIo501Q1TuBOwGmTJmiCxYs2KMTavxttPE6IP3LHYbiT2GUfjN5Lgdt+neIvwEUAX7AgfKfYYQv3KPzduC2/QHa7gApwbtUH9L/j0hg4l6Nu79QtXF2Hk+CBJr8UxkIfvwYRinS73YkOL3HMVyngeaGz2FbKxDxoRqnxHcGQXc73vfE9YS5bxxScR/q7CLa+n/Y8VeAEIHiqwiVfAlJ/3HomJ+9Hrf9fnC2QGAqRtHliFGwdu0pIrJpT/rVNzi8+8LwvNub1WurdjMPE7gV+CiewjZfRJ5S1RVpzWYDjao6RkSuBH4BXAHUAR9T1e0iMgF4gU6F73Y8Be9tPEF8LjAn74n3EfvSa6JGRKoBkv/W5mizFRiW9n4osH0fzglt/RkQ67I3Cu33oG6T1ybyWFIIRwEn2T4OzTegTt2enzv2ErT9CUh4mra2gzaijdeibtsej7s/UbeBOHZKCAO4KHESqDqQxw9Kc+MXsa2lQBTVViBOm72WaPAMCH8KQhcj5b9AKh5A3UZad52HFX0cdRtQdzvx1ltpq7+aroqLG30Rp+5iNPogmngdbbsFZ9cs1N7cx3ehwO5QwO3Ff3kwDVinqh+oagJ4CM/8mU66OfQx4GwREVVdrKodcmU5EBKRYFIulanqvKQWfC+5Taj7nH0piJ8COrwgPgs8maPNC8AsEemfXKSbldy3T1B1wF6b+6AEwHrfex19AE8IZzWC2J7/WGr7XbnHVRdi++yy+xQ7ch/ek2GOY8Gz8Z4Ou8exN2Mn3gOsLkdiRGJzkLLvYfT7FRI6BxEf8bY/otqG94PY2daxlmEn5qb2qMZxW/4L70fTSbVDm3FaftSbSyzQJyiOunlvQJWILEjbrusyYD5mzFQbVbWBZjIffQE+ASxWzy42JDlOT2PuF/rENCEifwM+jHczt+J5QvwceEREZgObgU8m204BvqSqX1DVBhH5KTA/OdRPVLXrol8fYgBBsjViAKfTTqzt3fS3ejiWB06uhwK8+bjdHTu4cBKL8MwH2WjOH69MXGcnIn5cN4aL9xeRDgOV2qi2I1Keam/FXiNbaAMawY6/jT94uvc2sai7M0LiX6i6iBTc5vcXnkbcK1NrnapO6eF4PmbMHtuIyHg8c8WsXoy5X+grr4mrVLVaVf2qOlRV71LVelU9W1XHJv9tSLZdoKpfSOt7t6qOSW739MV8ukNEIHwJns0+44i3IOSb4L0NnoVnF+5KAIKn7fkEApNIv+UXXrMNs3otZvVqjNIvIyJ5bxdccMGezyMPLHsLbZFniMXnZ5gADN8ocmvEAcQctdtxxTeSOjvGZsfHluTW6njfBzH6IVKW2d6s6GakYBfb78G14KnWGjT6HGotP9BTOWD0sWkiHzNmqo2I+IBykt5cIjIUeAL4jKquT2s/dDdj7hcO9GLdfkdKv4Pa68BaBiiI57kg/e/0BDUgxdehsWfAbaFTGwtDcCbiP2HPz13yZTT+ctJjAua8EtnjsZ577rk97tsTqja1Df9OJPoMiB9QTGMA1QMewu8bgb/4c9iRR8k0FQBi4i++erfjb2r8KW1qosn+LtCgJjgG1eXfTf0NOggWX0vEWpa6Z2knJBC+qPNdYBK5hbGBBD6037RhddvQxn/zzFxiAi5qHo1U/BkxuvtROfxQFKdvnQ/mA2NFZBSwDbgS+FSXNh3m0HnAZcCrqqoi0g94FrhBVf+VmqPnzdUqIjOAd4DPALf05aTz5cgTxEYRUvkAai0FawUYgyB4Ot4PaLKNOQAqn0bb74T4KyDFEL4aKbps787tGw0VD6It/wPWwtR+Z8fYXo1jVndj5+4Dmlp/TyT2HEocNA6A7UTZsesKhg2eh+EbQ7D/bcSb/gNPGCsQJNT/FgyzZ/Nawt5BY+TFlBDuQBGapYzRxVdm9fGHzidQ9C6J9gcA8YSbOhT1vwXD7PSIFAlglP8Kt+nfATu5hUCKMMp+vDe3pFdo841gLcFbkE3utFehTd9EKv6y3+ZxMNBL00SPqKotIl/FW0MygbtVdbmI/ARYoKpPAXcB94nIOjxNuOMD9VVgDPADEflBct8sVa0FrqfTfW0OB8BjAkAOxQod+bivqb0Jbb8NEgvBGIgUz0ZCZ++nGeZHh/a3p4J4X/ztNm4fj+tmm+lFiqmueohQcEry3Bau9T5gYPhPwPMu6pnm6Busr/sKjrbmOCpMHrYGQ3KZhJKLfPE3EQnjD30EMcpytlN7I27kQXA2g38qRtFliFGes21fo24bWjuD3Db0ADLgVcTM5U5/8CIiC3dju83JxJMC+sqc/K+1asi2PTrP4cJhqRGrtRptuMILSMAFZzPavBy1r8Mo+cqBnt5Bjes2d3PEwHFrUu9E/JiBST2O5ahn1jGTwjXgG4LmWngDTClFevg4mr7hmL7dmz7ENxKz7Hu7bbdP0Fa6XXYRP7gNcIgJ4r2hLzXiw53DUxC33pRtU9QotN2BFn2q4ODfAwHfOBL2iuwDmiDgPzGvMVqtrbxb+3Nqo4sAZUBoItMG3kBZ4GiKAhNoiy8h3RPCkDCDy76QZR8+5DAGggSTCkBXXC/q8AhBAesQfNo+UBye/jyJbswW4ofE/NzHCgBQ0e+/syLWREIUF30Mv29YN706iTvNvLDlWmqiC1AcFJfa2GJe3HotMaeRsVV/ojQ4GZFgUgsOUlV8OdVlX91Xl7TfEDGh9NtAl4g/CUPxV3JGAh6uaPKvn+92pHNYasSeVmJ3c6x4/87lEKMoNJNBlX+lofknJKxVGEY/yktm06/0a3n1X9/yNI7GyHTHVByNs7b5CU6ouJZjBz1E3N5Cwqkh7BuDz8yR5+MQxSi6ApVStO134Gz1cmUUfwUJf+JAT23/ouAU5GveHJ6COPRxiD5CdiCACYFpGXvU3grxVwGF4NmIbyhHOkWhmRSFXt6jvnWxpThJb4t0HE1QF1uaeh/0DSOYh4Z9KCLh85Hw+Qd6GgcUL6CjQL4cloJYSr+FWovB2ejZhgmBGEj/O5C0VXm37XZouy35TqH112jJ9RglXz4Q0z4sKPUPQ/ChZD6RCCal/sKP3JGD4BxkQTYHM4enIDZKoPJxSPwLrKVeGsfQ+YhRmmqjiSXQdjvQRXtr+yMaOAUJnLx/J32YMLb8UtY0P4aTZhpSBZcAo0svOYAzK7A/UcAtmCby5rAUxIAXSRU83dtyoNFHyBLCAMTQ6MMFQbyHlPiHcPrgX/BWzQ9wXJtaK0StFULEz7q132da5SzOqf4MZh5+xwUObQoacf4cnl4T+eA2kju/h0IyHWaBPeOo4hlcOmoOxaFLqbPLcBEctbE0zrv1L/DMtj8f6CkW2MconiDOdzvSOWIFsQQ/4rkVZRH2jhXYKxRY1PQ2tmYumFqaYFHjq0SdvchiV+CQwFXJezvSOWxNE7slfAFE7gJ7M50miiCYQ2Avq3D0ln2ZO+JA0WY342ruUjmm+GlM1BAOj97Psyqwv+jQiAvkx5GrEUsQqXgYiq8Dc5i3FX8RqXxkvznen3/+nrs47U3f/UGxWUZ3qSkdtSj391gZp8AhjiI4GHlvRzpHrkaM510hpV+DPIMV+ppnn332gJy3Lr6FN2ofZEtkOUVmOTOqLmFC+Zl9GmLsM/xMrZzF/PoXsLQzCY5P/BxXNo1iX+6kPQUOHwomh/w5ogXxkUhtbCN/2fBtbDeB4tJmNzBn+23siK5jVnXX6jR7x7nVn8Fy4yxufA1T/DhqcVzZND4x7NAPZy7QMwXTRO8oCOIjjFd23o3lZialsTTGosY5zKi6lLI+NBmYYvLxoV/inMHX0JCooV+gimLf/klJWeBAIzhaMDnkS0EQH2FsjizLud/Ex+b2ZUzo9+E+P2fYV8IQX0mfj3uoEEu8R3P7/ThOA8Xhj1JadAnGYZ4AyAtxLgjifCkI4iOINruFqBMg5gqmuIQMC6Pj6VEgZBYSIvU1DS1/oKH1t3hFg10i8TdobL2DYQOfwUyL9DwcKZgm8qfwk3WEsDWygZtWfINWxyCufiJugEa7GDu5oGJgMKp44l6fx1WXFc2bWNK0noTbTQa8IwTL3kZDy/+hGqUjBY5qBNveTGPrrQd2cvsYVc80ke92pFPQiHeDOrsgMRfwQfCMbkv0HMyoKvdu+j0xN73cvaAobU4RAwPKFSN+hGnkLlOUL89ue4ffrfk7dtJ/2ED47KhZfGbUrN30PDxpj71ILhc+JU5r5HGqyr+7/ye1H3ELGnHe7FNBLCLjgIfTdo0Gfqiqv0tr82HgSWBDctfjqvqTfTmvfHHb7oS234P4AAG10bKbMIou2m3fg4n6RC1NifocRwRXDWYf/TsqAntXwmdJ43r+b/UjGUHjLspfNrzAsKKBnDlo77XtAocOntdEQdPNl30qiFV1NTARQLzqktuAJ3I0fVNV9284227QxHxouxWvGm9aMciW76OBkxDfiAM2t97iquP5COdIrWGIiSndfwxs12FN61YMEcaWDsXspiz9bWuf6i5zB7eve4oJ5aOpCpYe+uWQekFx6KPUka1TCAFKiw73THQFr4nesD9NE2cD61V103485x6j7fcCuWqP2Wj0MaT0W7n7OXXgbAFzOGJW5n2+mL2Tmvbnsd12KsOnUh6c2GdCqyo4mLBZRMLNzjbX319JmS+7hp+q8kbtUn616hEURYGQ4eeHEz7NxP5jstpvi9V1e/7aWDMf/+evqQgU890JH+e0AeP26noOFfy+oVSUfZOG1t+lFutEivCZ1fQvPbx9qQteE71jfwriK4G/dXPsFBFZAmwHvq2qy7s2EJHrgOsAhg8fvs8mmcKtI3d2NhvcXVl7VWNo03e8ah8SAI2joXOQ8v9FJNDjqba3PsHK+h+jqig2G5vvoiI0g6LQudREl1Lir+aY8gsp8Q/ao0sxxOCq4V/mrg9+haUWoBiY+AwfUyou5Hvv38bOWD1HlwzlqmGzWNS4nns3vkSbHc0YJ+rEuWHJXdx7ynexXZf7N7zJe42bOCrcj36+EtrtXD9cXl7ahGuzM9bMdxc9yB3Tv8j4fkdGkviKsq8RDp5KS/v92G4DJeFZlBZdipEz4dThhVOIrMub/SKIxZNEFwE35Di8CBihqm0icj7wD2Bs10aqeidwJ8CUKVP2fcrp4EywlpGds7gICXwoq7k2fz9ZcikOHaWCYi+hEkLKb+r2NDG7hpX1P8ZNKy/kapRdkddpbltMq2ti4Of9xgc5+6ibGFo8Y48uZ0NbI9uiJZT4ovjExnJNhhVN5LZ1zxN3vQxpNbEG5tYuR/F16/HgqMv9G17myS3LSLgWtrqsa91B0BTMHCmGVSHhdB6IuxZ3rX+V30z+zB5dx/7AUYd3Gxbzdv18AkaAMwacxviycXv8hBIOTiYcnNzHszy46cg1USA/9pdGfB6wSFVruh5Q1Za018+JyG0iUqWq3T/r5kA1Bon3vErN/pOQHuye+SBFV6GR+8B1IFX2xw9mNYQyvQDUbYHY80CiyygxNPIkTvHXMMyqnHOqaX8ezVF2XEQpMlppdfvhYoHC6zt+xFVHP40pvfNu2BzZzl83/Z2EC7FEpyZW17QGS006vBhdVeKupl1vNpbavFbzPhGn81oViDlKiCABn4WjHa5aELcNHNeX0XZd685ezT8XDfF2XHWpCvWtL67t2ty08rdsaN9MPGnKmd+wmNMHnMLsUVf36bkOZxSwtOCUlS/7605dRTdmCREZDNSoqorINDypkGuJv1vcyJPQ+t/JrgoEoP8tSJdCob1BjH5Q+Q+vGm/sJcCE8EVIydeyTQ1urfcDoJmCOOomaNN2tGYaIn7CRZ+mtPx7Gf0djabqu6lCQn24CH5xEBRbDdrcIAk1MRH+WfMnzhz0Ja8CSZ68WvMWtpudklIAn7gkkosq+TxmhAw/9fGodz+6YEqQH0/4LBWBMO/UreWe9W9gu10LuMKI4gF5z70r61tr+d6ix1nbWosAQ4r689OJH+ekir4pRPpG3Tw2tG8i7iZQ9e5J1LF4vfYtzhhwKmNKRvXJeQ53FCmYJnrBPn92EJEi4KPA42n7viQiX0q+vQxYlrQR/x64UnOpiN2g1lJo+QFoBLQNtB20EW28zvMB3pu5mwMxyv8HY9B8jEFvY5R9L6PuXQrjKOiSezfqJmjVRHKZy0Y1SqT9Xpob/yOjXWX4QxgSwFaDnXY/djll1Dsl7LD7sdMqp8EpJq4+FAMbYUHjCzy7/Xfkg6MOj2x+iae3zSNiCwnHyKwjJplerrv72ggQNAOo5tbIVZUiM8DRpUOo8g8kZvmJJ3y0xQI0R0I0R0IkEkGuHHFaqk9zIsqiui1sjzTv9nqaE1E+M/cuVjbvwHIdEq7DhrY6rpt3L9sijbvtnw9v7JqXEsKWmthqYqtBxHG5dd19KW2/wO5xMfLejnT2+R1Q1YiqVqpqc9q+O1T1juTrP6jqeFU9SVVnqOpbvRq//S/krD2nDhrN5SnX94hRBEXXAN5jv6rSrtmaIMSIRZ/DcXak9pQHJ1AVOoNddjk2BoqgGIDQ5BYntdROEemoxcqWN2iIb9vtvP53xT08tPl5Yq6F5zMsJBwzQxinay0iYApINyJ5QvlobpvyDc4cNCGnG1u7nWBezRbOnnML31/0LI1RJZrwY9sm6gqqguWY/HLp69iuy08WP89pT9/M7DcfYtac2/n06/fRlIjmOLPHP7YsJuE4WZq75Trc98Hbu70f+dIhhD0ktW2L1PKPbS/2aqwd0dW8uOMPPLvt16xtnddtsvzDDVUKkXW94NC/A/Zmcj9Uxz03sv2ElH4bSr4AUgwEcLt50BcJYFtrUu9VXVoZgp0Uvukk1Je1DzxBuTnyfo/z2di+nYWNK1MLcR09AWzXwCcm/f3lhMwSQkYAAcJmkCFF5Zzc/2gCho9iM4SBQcL20R6p4PWt9dy48Fm+OOYjVAZL6XhuUfW2SDzA71f8k12xNtoSFq7rhbqmrkHBcpVN7Y3csOBpHtuwhLhr02bHibs2C+u28OV/PdLtNa1q3pH8UcnEUoeVTTty9Og9M6tOwZeKMMy89w4uz2x/Ne+x3qj9C3/b+B2WND7H8uZXeGbrL3l40w04OX+kDzcEtxfbkc6hb00PTAZ7JdDlwy1FiH//RXOJGEjJ19Di68FtRmpORbU1q51iYZpDUu//Vftb1rbMQckWuV4Qcg5BLAYhs/tsZhvbd3DDkttJ5BBa4Gmm5w4+ncuGnkfACPCvuiXUxBoYWXwU0yqPxxSTHdF6bl31CnO2rSJiubjq2bHfqt3I+S/dzvSqEWyxoiCOp0HavmT9MXDtNOELqCgigohndG23Ejy3ZQWJLnZrS13eb9zBxtYGRpZWZM18TOlAgoaPeBePDlMMxpTtud0ZvKeYpU2bqI0KplagWk8uJ4k2O5LXeLtiG1hQ/w/sNG8YS2PsiK7h/caXmFhxcFdY2VsUCppuLzjkBbEUfw6NPgoZWoYJUgbh/f9hF/EhZiXFJdfR1nobkP6o7cfvPwGf3wuIiNqNrGl5FpdETp2gSBK0aZBcIvrokqk5zx+xY/zH4ltotyP4hJzCpDpUxedHfTL1/qxB2WMNCPbj+W3rkkI4LUUb4Kjydt0mXDWQtIcqVXBtI6OtdwDvJ0UEUMKmj5id+xHdLyZbI005BfElwyfxp7VvEO9ipg0YJp8efUrO8fKh3Y7z9QV38UFbDY66mCLE3VKqwu34zcyTDSuqzmvMVS1v5tR8bY3zftOLTKw4H1WX1U0PsLrpAeJOI6X+4ZxY9TWGFM/c42s5mCi4r+XPIX+nxKxGKh4C/1S8y/FB8Eyk8lHkADrNF5f+O+Hiy4EgIqVACH9gMv0r7km1aYivx5QAHUKrqzEjLAkM3OQRIWCECRhhLh/+Y/xGMOd5X6tdhO1m21E7CBoBLjhqJi9tX85tq1/lyS2Lidpd3e6gzY5jZWismRLdVcXo+gOhudt6eTok/R2VwdwpN+OuzZiy3MnpK4LF3HXq5xheXEHI9BM2/QwMlfL7aZ9iZMmeJ7T/3apnWNOyg6iTIOHaRB0LVw0aosWkLxsHDD+fHpFfaLKqm1yozcbFu6+L637DsoY7iTn1KC4t1kbm7fweW1rzN38crCj5V3AulFQ6DDRiAPEfg1Q+gKoNCF5aiwM8JzEp7/e/lJb+J7a9FsOsxufLjAgs8lUm55zDyq3QpkFMAT8+JvQ7lyFF4xlbOoOA0X1S8S2RXcTcBCDYauCjU6MTgSn9x3PHqoU0JaJEnARFZoBfL3+ee06bzZjSzsQ/pf4QYdNP3Ol5ccknBnbSk0By2LmzLgq48aTz+NeODTy3bXlmc4UiI8jgcGeGO1XlvtWLuXP5OzTEIxzffxD/PelSBhcXYavLqJKqvQoFd9XlhR3vYWm277Tgw0cRLhGGhqv57MhLObn/8XmNO7bsVBY0ZJomAHwS5OiSaby96wE2NT8GZN5fR+Msqb+ZYaVn7fE1HSwUNOL8OSwEcQd7G8SxLzDMCgLm9JzH+gdHUR4YTkN8PdqRrza52YQwjBJ86jBz4LVMqvh4XucbXVJN2AgQdRMogqWe3moAMypOYGubj5poK07yfG2Whe3afOzlP3JCv6P46nFnMHPwGEwx+OLY0/n9yteIpQljdcG2TFzHIGiYHFtZxYZoDYoyacBw3tm5nbiTOyDEdQU3YfDq5g+YX7sV2xJMf+dPkGsLLZbDuuZ6xpR7eTp+NP9lHlm3lKjtPeYv2LWVz7z8MLefcQkDwiXURtsYVLTnQR2Oul00/04Cpp9vH/t5plYc3WthXx0+huPLz2Rl8+tY6oV++yWI3yjlrfrHCEmcKtPFzDFsu72Dedtn05pYht8sZ2TZpxlZdnWvfMcPNAq4BRtx3hx8kusIY9aQX/L81m/Tam1LLnAkcKhiUPhMju93MqNLJhEw8jexzBwwkT+tf5q4ayU9NwQF/EaA86tP57p5D6Q8OmxHcFyDjmXBJY3b+Po7j/LDiedx6YiJXDv2VBx1+O3y1z0DiQuJaKdHQdxxWVxby9SBw3j0nGsAuPrVB1hct5V4UripgpsQ1DY7ujG/Ziv1sQhgYtuaphULAb/J0l3bGVnan4Z4hL+teS9rUS/m2Fz76qMU+4JYrsPUgcO4ZeZF9A9l3ydV5bktK/nr6gU0JWKcNWQMXzh2OlUhzzTiN3yMLhnI+rasoE9s1+G4siF7rHGfU/11xpaewtKmF7DcGEPC43mr/hEctUioi5jdGZBcGmLvIAK23c7qxptpTazhxAE/3aN5HBikUKGjF0gvYicOGqZMmaILFiw40NPoM1SVV2vuZ+6ufxBxDRJq4hM/QSPEN4+5iYpg7lzBG9p2sLBxLcVmiNMHnECJ3xNEO6L1/HLVA6xq2YwgDAiWc9Ww8/nR4heJuBHPZKuQsE1ymRLK/CHmXfBtfIan0eyKtfKdBU/yxtbN2Jbk7PPXsy/njKNGE7ET/GTRSzz+wfvYtuIkOuzDXfq4aXtM9TZvLY+AGyBk+rlwzDE8tWk5bVa2DTvdHu03DCZUDOaJCz6d1ezGd+fw5MZlRBxPow4YJqX+IM+e9wUGhj3Pk4UNH/DNhX/JcPULGX4+PfoMZh99ds57vye8WnMX79Y/kXr6GeJrwC9OZ7mqjushQcjMfKowJMjMIU9R5B/C/kREFqrqlN72GzqhXL/+yKl5t//O+Of36DyHC4Vnh4OAmBvlhZqXaHL8JJKBBLZaRJw2ntr+QFZ7V13+Z/kDXL/gZu5c/yy/X/MEl/3rx8yrWwFAdbiS3578dR4+9cfcN+P7/GX6jTy84X3a7HheYcy267KpvSH1fkColLs/dA3+nB4cHnevmA9AkS/AVaMmUWqV4kRNcLuxG0vH/wSc5Kae1h13HJoTMR5bs4xEjzZqb1zLdVnVWMvqxsxIynXNdTy+8f2UEAZIuN7Ytyybm9o3uWI0t039ItMrx9LPX8TY0mpunHBZnwphgJjTlhLCADvtcmz1AmwUE0MC+MQlaOS2VzfG3+vT+exrnKRWnM92pFMQxAcB61qXY+RYYFSUFS2LsvbP2f4ub+5aRty1sFybmJsg7lr8eNm9tFidfq6lviI2tjZzz9p5zK/biKOKZRmpAIzusNWhzJ+9INjt05N6UXUAbYkE1zz7SNL0kC+eIFYXcDo/knHLwXJyuPvnmIZpGGxqbcrYN3fnhpwXaqvLy9vWZOwb328YN0+5lufP+gH3nfp1Plp9Yi/mnx9jSqbiT6ve7GCy1e5PrTOAQcUXc97whylJ5K1DAAAgAElEQVT3F+d0OQQIGP36fE77ClWv+ku+25FOwUZ8EGD0sAiTa4HmiW1zk54R2fyzdgkfG3IK7XaCL/zrPlY312C7Do4qdtJO6yYMfKaTtAxDusZqIpzYfwgDQiVsbGnk1wvfZO72TZT4AwwKlbKpPUdOB4HzRxwLwHMbVuPskblLwDY7p+IAruA6YIS98fyG56GRM0u06zK2X2Yi/rDPnwzFztaqQ+be1efbE8aUTmdgaCQ1sQ+wkwmiTAkQMCs5deA3CJpFjCi9ivXNf8bVzNzOpoSoDOde9D1Y6euADhE5F7gZL+PUn1X1512OB4F7gcl4icOuUNWNIlIJPAZMBf6iql9N6/M6UE2nw/8sVa3t04nnQUEQHwSMLZ2Q8cjagYnJSf2y8w+3dZOA3VYnlcz9V++/yIqmHamFLtftDMpQFSzby1QnhhIwTAwRfIZBZbCY30z7BJtbmrjwyXtptxO4qjTGowRMozPBXRpl/iBXjfWiGGva24jZXQIZuoYNdriGdNmVauOVd/ByXqigEQFDwWdyxbgTeXLjcqJpnhlBw2T6oGGMKssMAvno0GP40cLs3BAh08eVR+//GnqGmHxqxM9Z0PAUS5tewlGb48tmMr3qEwTNIgCO7jeblsRKdkXn4tXWNhDxM23wHzEOQq+g7vD+hH1nckiWWrsVL4HYVmC+iDylqivSms0GGlV1jIhcCfwCuAKv1M4PgAnJrStXq+oBXXQ6dP6yhzEBI8jVw7/C/Zv+gKsODg4BI0ixr4yLjsrOgTut4lie2/5OygWtE6EyUIGq8o/NSzK8DTTXghmeOWBYSQVXj5lMkRFk8Y5aZr/4OHXRCG1Wpk054bgE8VFdVsLmtiYE4dRBI/jVaecT9nka5gkDBhP2+Wm3LQTxzBnJRThDxPPY6KrSamo6HlkKrIArWAmluT3BD6aezS8X/5OobQPKhSOP4zuTPswDy5ewun4X4yqruGjscVQEi/jl9Av5r3eeQVVJuA5FPj8nVR7F58fteYrUnmi3Y7xWs4Rd8SbGlg5hRuVx+IxOs5PPCDCj6jJmVF2Ws78hfiYPupnWxHqa4u8RMCsZED4No5c5qA88fV6zbhqwTlU/ABCRh4CLgXRBfDHwo+Trx4A/iIioajswV0Sya3wdJBQE8UHCif2m8Z3wr3mn/jUarTrGlIzn5P6nEjCyyyxdM/JsXq9dQrsdTbmiqULUhhsXPcWao+u7qbCRO6PFyJJKjisdwtVzHu7UNLVLl468PSpcM3Yynz7uZAyEQJeyHDOHjmR4WT/WNzWQcJ2UMDbFwLQEy3K9T116NwfEAQkIPp+BK9qteWNjUyMfSozgN9Mv5NgBA+gfCrOttYVZD91DwnGI2BZFPj+/emcuj11yFR8bcTxTBwzjmU0raEpEOW3wSGYMHLFPipiubtnKNxfdgaMuMTdB2AxSFSzjD1O+Srk/dyRhd5QGjqY0cHSfz3F/4fkR9+oeV4lIulZ6Z7IqTwdDgPQsXluBrraaVBtVtUWkGagEdldk4h4RcYC/Az/rTRrevqJgJT9AtFjNbIlsIOp0LmpVBgdy/lFXcPWIrzC98sM5hTDAwFB//jTtm5xQPhZXBccVIgk/rfEgcdfm3g/eYlRJ5mO6YeT+bIVNP9eMmcJ/vjkn43E/LftjhgbrMwz6BUOETF9KCCcch20tLcRsC0OEhz92FZeMPZ6Q6UOAiQOOwp8wcRJgqIFhGUhMIC4QE8TxclYUuQF+OPUsDNvIuSAnwLqGem5643W+8fxzfPKRh9jV3s43Xn6W5niMSNIkErEsmmMxvvri0wAMLirlC8dN59snfZhTBo3MEMIx2+42AKU3uOpy45K7aXdiKft91ImzI9rAzav2TzrWgw0HI+8NqFPVKWnbnV2GyyXVu35K8mnTlatV9QTg9OSW7QO5HyhoxGmouhB7Ho0+DBqD0HlI+HIv33AfEXdi3Lvxdla0vIdP/Dhqc2rVWVw69JoeF+26MijUn5gVpjGSPbeEY3PcwEFsj7YSdyxPqRXwm4LjeFqsIDjqMnvcDMaWDmRzF4+Dnjh3xDGAl2/ilnfm8adFC5OFT+Hy8RO48fQz+MXMc/nFzHNRVeasW8N3dryIlVZKShCki5Ui7Pfz6LJl2Lbb+clMsxsrYNsuDgoORG2La598nM2xZm+cpG254+XqXfXc/O5bfGNatj/r2qZ6bpj7AotqvbzO0wYP4+cfOoeRZdkVrfNhVcsW2p3svNi2Oryx6/1kMqEjR+/pyDXRh2wF0suwDMUrNpyrzVbxwmzLgQZ6QFW3Jf9tFZEH8Uwg9/bVpPPlyPlk7AZVRZu/hTbfAIl5YC2G1t+g9Z9A3fY+O889G/7AipYl2GoTc6NYajGv7jXm7Hh89527EHNy57V1UcoDIe4//XOcPmgM5f4w4hpg+ZFEgHhcGBKsYM6sL/GN8WdgimC7PVeeCIsff9ykJB7kuqf/wZubNnLru29z58IFRCyLqG0Ts20eWb6MH7z2SqqfiBD2+7t1yQJP1oZ9Pn56xlksr631hLQtpPIddSzeWWlJ6xVcR/mgoQk7okhCvFJ7CqKCqOeXfNuCd3l+/dqM8+2KtnPp0/ezoGYrjnpmkHd2bOHjT91Hc9xbCI3aFuua62lO5F4Y7UrMSWQnQUriqIt7BFb26OMKHfOBsSIyKlmM+ErgqS5tngI+m3x9GfBqT2YGEfGJSFXytR+4EFjWy8vsEwoacQfWYoi9Smbayhg429DIQ0jJ7L0+RWOintWty7C7pEdMaILXaudwXvWlvdKKzztqAiuat2cJ5LAZ4OzBxzO+/1HcNuMqTvn7rUSiHVLNAQc2NDXz6Pr3+dbEmbyy6YNk9JvmfLgrNYJYERd1oN6KUr9tK0trduI4SqKLAI/ZNk+uWsl3P3Q6/ZIhx6cNG0Guqh+GCEV+P9OGDuUrU6Zz8uCjCPtfJGJ5C33iSOfCnQKS/E51XApkaMyiQte8QwnH4Tdvz+XcozsLg9+3cjHxLpU+XJSYbfPQ6iW0OHHuXjEfQwws1+G8EeP4+SnnphYkc3Fc+XDsbqpvjCsdit84sr5qXoWOvtOIkzbfrwIv4K0w3K2qy0XkJ8ACVX0KuAu4T0TW4WnCV3b0F5GNQBkQEJGPA7OATcALSSFsAi8Df+qzSfeCI+vT0QMafwXPy6UrMYg9A30giBsSdfjElyWIwYukizlRinz5L+pcPHwSj25ewOa2hlTlirDpZ3LFCGYMGA3AOzWbU7bTdGKOzf2rF/OtiTO5a+lC1Mb7NHQsziWllE9MSglR47Rl9I9aticQXcCQjAU90zDY3NycEsQB0+TOCy9m9tNPoOoJvLDfz9H9K/jbJ66gyN8p4C47fjwPL3s/M+tbh8SMC/iSNgqDjGTL0uEV7ZJV13Rjc6bZZVHNduK2nbUQGXVsHvtgGVsjzRn28uc3ryHu2Nzx4e5TYIbNIF8acyF3rHsmFSptIAQMP98Yl1/qzMONvk5vqarPAc912ffDtNcx4JNd+yWPjexm2Ml9Nb+9oSCIUwTwvt05tJquVZv3kAHBwdg50i0CBI0QIbN3+ZMTjsMvJ13BW7VreG77+/gNk0uHT+aCISemNOvGeKzb1YqOHA6N8agnyGzN1CgVPjpiDK+s/iCzo5IqiCJIZ93UZGWnqGUxpLQso8v0ocN469rreGbNauoiEU4eXM1pw0dgdLFZfOe005m3eQtrGzILeUvyfNoh+HOQEsZdsByXvy1dyhUnnIAArZE4Ejc6WxoKPsVnCpvaGrOSDMUdm9e2racm0tpjprdLhp3GsOIB/G3ja9TEGjmufDjXjPwII4pz5wo5nPEy/x34dLSHCgVBnETCF6DtfyZbEIeRoiv65BxBI8TxZRNZ0fwedlppp4AR4JzBl+RtlqiPtfNf85/knV0bMUQo8QX5/sRzOH/Y+Ky2kwYche06STtr2qO+qZxQNQiA6dVDefaDNV6oqUtKmIVNP184YTKvrfkAJ12+JX9LOswNKQXaxtNGBSqLshcRy4IhPnXCST1eW9jvZ9qgIayrqe/8QXA7haznDkfPaY+7ovCzf77Owu3bGVXVn9W76tNmnxTuCcERRX25bbkBw8em1qbdptycUnEMUyqO6cXkDk/2wH3tiKYgiJOIbwxacj203YGn7jkgRRCYBqGL92psy03wt8338079W563AgYmPvwi+Ewf5wz6OGcOPDevsVxVrvnnvWxqa0glZI85Nt9d8BT9AkWcOmhURvvq4jIuGTWeh1csR900u4NrUGGW8J1XXuD5NetwjU77sCCETB/TqocwpXooZ40azasbPsBy3dTiWVebb0oYKxTvZfhwZXERATG983XBFMHuyc2z629ZcqEvqjbPrFmNudnIyK/szT05e/Xuby4hn3BtRpQeOrkeDjxSyCHRC/a5IE4ayVvxdDG7a6o78Zw6bwbOByLA51Q1O9PNHqBOPRr9Bzg7kMDJEPoo0oOZwSj5Mhr8CBp7CtwIEvoIBE7Za+f/ezb8iSVNi7HSbMOmEeAjgy/g3OqPYfaiosjbtRvZGW1JCeEOYo7N71f8M0sQA5zQ7yj+zkqsVCSedz2vbPgAw/YKfuLgabMGVITDfHbCJK6f6EWf3XTWR7n8sYeoaWsjYvXsc+sXg0vH51fFAmD9rnreWLeRoN/HrGPHUFVSzCcmjOfP7y7MEsRhnw8bF1FNmig6jxmG8LFx43hhw1ov4i49ICX5WoTs8OsMBBICgUxhHDRNzh46Zq8S0B+JFKoz58/+0ojPVNXuolvOA8Ymt+nA7WRHzPQajc9Dm76UfO6Mo9HHoO23UPkIYmQXpuxA/Mcg/m/v7elTNCUaea9pcbanhJvgldqXOL+6d9r2+ta6bl3NPmjNfYsfX7siU6gpYHmP+E7ycV+QVITbyUOq+cbkzmKcFeEiXrj6c7yxeSMramu5b+F77GrPzq4mwDGVlXz79NN3ex2qyg+ffYWnlq70fGwNg5+/+E9+fMFHuOSk4/mfcz/CDc+/hCkGiuK4yuypUxhcVsLPXnudhOPgOErQZ1IWCvLQFZczqn8FbYkEZ9zzZxqi0SzN3RTBb5g4PQVwWIIhQiBsYIjguC4XjjiOm2bM2u01Feikr70mDncOBtPExcC9SX+/t0Wkn4hUq+qOPR1Q1UKbvgaa7ooWAWc72vJzpN8v93rS+VIT24nf8GHn8PmN2BHibpyQ2X0Nuq6MKOmPzzCyKhl3HMsLW3KaF8CT0Utrs6tVmIbBmSNHc+bI0UwePIQvPP4EMctGFcQF0xQ+P20S/zVzJtubW/jNy3NZtHk7Q/uXce0pk5k0PDOh+fMr1/L0+yuJ2Z5QtBzvgr775As8/O4S/uucM/jX9dfx2voPiDsOM0eN5KgyTyOddFQ1Dy19n40NTSSiNu2xBLe9/g6zT5lCRXGYEysHM3frJrqWUI0kbLAUCXRd1OtQmb3/uQkYVzqIX51zDtVFZZQGchdqLdAzBdNE/uwPQazAiyKiwB9zhC7miiEfAmQIYhG5DrgOYPjwzCKcWSTmQ1ZCHAAbYnOA/SeIq4IDsXPmfYCgGeo2jLk7Ths0mv7BImKOlZGPIWz6+cpxucuwf+KY8ayor+l8ZHdzC+EOBheX9DiHcVVV9JcQtfH2ZI5igQT8/e1lbNjawNsbt+C4iu26rK7Zxdz1m/j+eWdy2cmdia8eePc9zwWuKwqLt+3k2nv/zq1XXcQlE7LNHOMGDODCY8Yx+4EnSNg2jiqra+t4fuVaVEAN9WzeXSw+4uBlc0PB75kz3K725qQpY01DPW9t2sLnTprU470AT7vfF7krDmX2QWTdYc3++Mk6TVUn4ZkgviIiXaVFXvHhqnpnRxz6gAEDej6jZoeadmJ3n+B8H1AZrGRc6XH4uqQwDBgBzhl0XoanxK5YK79dOYfL37iFf3vnbv5ZsyprPFMMHjzjs5xYMYSAYVLsC1DqD3LjSefw4eqxWe0BLjtmAhOqBlPk8+828j5omlw/pWfL0M9feoNdLe2dUWwO4EJLNMHrazcSt5yU+USBmGVz05zXiVoWrqtsrGukIZL2tNIRmpw2t5hlc9Nzr+U8v6py49MvEbU6f4xcVRKOQ8J2sCwXMyFIIplMyAGxk3NFMC2DUMzkouHjGFqaZvfVzi1m2zy2cnmP92HRrm1c/Oy9jL7vlxz/4G/44TsvEclV1ukIxUXy3o509rlGrKrbk//WisgTeLHcb6Q1ySeGvHcEpkKOoAkQCEzf79rLdUd/mXs2/In3m5fgEx+Oupw54COcW31hqs32aCNXz72NiJ3AUgfaYFnTFq4ccQpfOzbTPjm4qIyHz/w8O6MttCZijCytxG90v+AXME3+duEV3PjaSzyxYgWWurl//oDrJk/h/DHHoKos21HDrrZ2xlcPYlBpp5b83PLVnTIz/am+gxxjm4bw17cW8eBb79EeTxBLFsgRmwwB7KZ9IjfWNXL/W4tpicWZOLyaGaOHYxhCQyTKtqaWbq+3Y1pCMkw6x3xsV9nW1Monx03g5vnzUppx+pOC5Tjc9d5CFmzfxojyfnxqwokML/c8J5Y31HD1iw+lAj8itsVDa5ewvKGGx869+ojXkAvua71jnwpiESkGjGRCjWK8sMKfdGn2FPDVZH7R6UDz3tiHAcQoQUu/A62/ojNk2QcSQsq+32NfVcWy3sN1mwj4T8Iwu1/Yy5eQGeb6MV+n1Wqh2WqiKjgwyy586+qXabVipNefiDoWD2x8iytGzmBgqKzrsAwOlzE4XIblOqxvaqBfMERlOHeCokeXL+PplauxnTSPgC7J2j970sl8c/qH2NrUzOwHn6CmtQ3DEBK2w0UnHMdPzz8b0zA8v+S0fvl83eKWzW2vvu0l9CEzIWd6f8MG1ySlJf/2xbnELJtwwM+YgZXcPfsyfIaRM3CjW3L4HYvAyP79mHX0WO5YND9lq+4gYJpsbWnh1/PmErNt/IbBvUsXc9t5F1FVXMS35z5HNGFnBMAkXIeVjbUs2rWNyQOHZoxXH2/j3vVv82bNWvoHirjm6Bl8eNAxh7XALtiI82dfa8SDgCeSHzYf8KCqPi8iXwJQ1TvwQhbPB9bhua99vi9ObBRfg/rHoe13g7MdAlOR4tmIWd1tH8taS0P9NbhuA2CgmqC45DrKyr6b9YVps+pY1fwC7XYdRxWdyOjSD6USu/iN3Is7pf4ySv3ZAhVgbu1qchUBMkV4u24dFw3Nbau8b8VifjH/TRx1sV2XGdXD+J/TZnHv0sU8vsrzljhr5Cje3LApJWxEkwnb074n4oAV98w2n3/gcbY0NWfYT59dvooRFf34t1OnMn3kMOZt2NJ1Kp3kEHyW43rmgY7z5W4GgOF07u+wI0cSFqt27uLWV+bxn+fN5ITqwby3bUe2jTd9/K75KNIImj4+P2USYysqOb58AEu21aSS2PvDBn7DJGJbqfEt1yXhOsx+4XECPjOZlD55A4Nu6qXtuiyp35khiGuiLVz2+h202fFU1N6Sxq1cNWoq3xp/mHpjaMFG3Bv2qSBOZtPPCqVKCuCO1wp8ZV+cXwJTkcDUvNqqWtTXfQLXrSf9Wbm97S7iBAkGZ1IaPBFDAmxqe4c5236E4uKoxfuNL9Hk3JryZBhWNI5Lhl7PgFDnlzHuJHiz7j1Wt2yiOlzF2YOmUu7vfNwPmD6w04QHntYmGASNzACJ9c31/HrRG7y+ZSPRhJ0hvudu28hZj96FJAQrqX0+tWo1ndXppPPfDrus65kI5m/bxnvbdrCrvT1LwEUtm7+8s4h/O3UqPzj3LC658/7MfBBZN5SMnBXpQjh1fTm6SUffHA0StsMTi5bzn+fN5BcXn8MV9zxE1LKIWjZhvy/ljmeri6tKQAwscfGbplcNOjle2OfjF+efw/GDBvKNp55l9c76Ti8SBYkJUb+F25FkqGM+PnBUk0K4Y4IKCcMTxgJ+02RwUeZi5y2rXqXZimYsrkYdi/s/eJcrR01lSNGepd48mPE+VgVBnC8Hg/vaQUE89hpezpC0L4trsMMBbfwjIvcDytEVP+L5HXdiJxcEXRVqLR+KQ8c3fXNkFXesu4FvHvsHin3l1Meb+ffFv6HNjhJz4wQMP/dvmsNNJ1zPcWVeAMaswSdw3wfzcdzO85uGi2u6fGhgZ8jshpYGLnrmXm+hyoau0srFe0QWV5BknbrUY3yaYMzFll0trKyp7fbr0xz1kiKNqujPj889m9/98y1qWtvIMjl3nCMp6KV7k3QWgpeVrbsKHbGkhjy8oh+vfG02zy5fxYodtYyuquDiE49jS2Mz97y7iM2NzUweehSmCo++t4wW12FAaQmfmzqJa6ZMJGCabGxo5OV1H3gJgNKwXBfXAvwdcxJc3FT4dtaMVVM/PH4xOHtoZkWe13euyXk9hgj/ql3P5SOnZB07HChoxPlTEMRJHGcHmpaQx1ZhmxNGU+GvXvaxtfU3EmQwCQVbDaLqxycOtprJtp7gizrt/GLldxlePIMVzTtoSDSnTA+JZHaun664m/un/xhBmFe7Gc+VtvPD67gG5w6eRLGv09Tx28VzidpWcqzdf9DT8/emJ07PMEvgZZh0Ud7avKUzYMT1zAQdp6quLMFyHL70l3+wZMsOIgkLU0B9XZwF7aQGnFNwpZFD8w34TOIJJ3c/hYElndnpigJ+PnnyCXByZ5Px1SF+ffF51LS08ck7HmRXa3vqNLtibfzhpXmcMnwYx1UPZMmOnZ6Hm+P9WCCgSZuvQZpGl/QOIQHq06xUmyCEDD/l4SD3nP1JgmZXD5ncXzMDOSDVpPcHhcW63lGwpifxB07MKF3f4ub+8igW/YwG2jVADD8iQsBwKDITmNjEXR/tdoCY66PdquOd+lfZGVtHiT+CdFFHY06ctW1bWNq4lc3tuQoJCA9vWMTi+q2pPW/t2NytXTQDN1MIi5XcOty5rKTHguNtgudTu3Drds4aezR+FQzbE9AdgrqusZ0fPfkK723eTiTh/ZioAgkw42DEvM3sMEN0CPGOOaS5h2VteK5z1UUlqbTDuWIu6poi2E7PSdYTtsPlSSHs3cXkw4Dr2Zp//dKbAIR8PuIxO6Wxi3beH5/fTN3HDrOFOILEvS19bn7D4PYzP868y77M8RXZmdYuGT6RYA5h7KjLhwcfvgmC3KSdOJ/tSKcgiJP4/RPx+08EPO3TUklpuJkoDU4oeSxpbxVvC5o2bXaAiBugzQnR6oYRgZBpI0CRL9PHNGYb/G7lK/xwyROZnggZZ1NuXPh06n2/YJq3haHZpoaumi+dLmLS9T8XjAQYTud1FgcC/O/HPopPs+tNJByHJ5esyJ1vQkm7I2kKY4cwTgpsI7lJx+sOAR4Fq81hS01zpl9x+uaCum7KRNIdr61aT31bjhDs5DiLNnvekcu319A1x0+HQK4KhXPGBKVs68k/V9jn57qTpnLmsNFZKT07+OIxpzOufBBFphe8EzBMgoaP/510CWX+3qU+zUXMibC06XUWNLxAYyI7KvJA0BHQURDE+VEwTSQRESoq76el5SaikYcIGTatTnZ+W8FPvVNGd8/cRWaCNifzy2WKIgK+lHQR2uIB2hI+drRtwFFwesjdurm9kYZ4OxXBYj5//GR+9u5rRB0LMUATZEaQKZBeUgh6iKQTL7d68hJ9psFVE09gZ3MbpkhmkEVSyuby7EgJyq4uYsljYpGqT5fLlpw1MwsvBXSatpy6DlMoC+X2SolZNq8uW8fDC5fmtjGLN4/ioCcQX1i1Luc4ALvq2xGfZ3bJvi7BdIRhleV8eeI0Lhs3IecYHYRMPw+cPpu5tet4Z9dG+gfCXDjsRAaHy3vsB2C5NpsjNRSbIQaHK7OOr255l8e2/BqRjihBl0n9Z3Fe9RczPH3aEmuJO7soDRxLoA9cMvOhsFiXPwVBnIZhFNGv302Ul/+MAW6Epu3nkHDqSFeNDAlg9/AgsTu3UMGz/bYmgqQ0aiCXwVTVaytCqvDkVcdMZFHtdp7ZuArHdb0ybRnFlz0Dp/qUYgkQt+3cwrMr6iX7+cyUk2lojxKP2xk+wtohFE0ImAZ23E1J1t0pNJJbJnbvvqZ4i2VmWkMg7PdxxYwT8fuyf7RWba/l2j8+hu26RBwrK8F96l+BK6ecAHj26O7YnfVn8qAhPHxF/nmqDTGYOegYZg7K3xTx4s53uWPd47gojroMKxrID47/PNXhKgDa7CYe3fIrbE1k/GAtbnyZEcXjGV9+GjF7J4trridibcTAj6txjiq9jGMrb8wwxfU5WrAR94aCaSIHIoLPLGZS9WNUhE9HMAGT0uBEJlY/SNjM7QsMEHUyc0eoegt/AEVmEaNLhjE8PCrDJU0EfKabEsiqyX62YMV8BOwwz29akypX/3+nX8BzF32OY0q8UG9JMzskh8DvM3j5M5/j+inTUhpgTjpMCg5UmCH8psnamrr00bxzdLxwwI25GK4nMMX1+na3uJYhhNMFop30F05uXc0Ahpsc2/XG8IlwwcnH8h/nZ2d2c13l+rv/QUs0TiRukbLyJN3yUpvjnfPzp3peCp84aTx+s/uvgPH/7J13nBbV9f/fd2aesn3ZBZbO0rtKEcQGihW7WGOLSiyJJsZEY5rpUdO+qWqMGkvUGLsiKiigoID0Xpay1KVsL0+bcn9/zMxT59ldmvkF+bxewz7PzL137jzMnDn3nM85J4spOkfTuHTIkKz9DgeW1W3krxWv0GJGCJtRYpbOlubd3Lv8z3Ez1uqGuXjRYHQZZUHNO0gpWbpnKi2xCiwZwZBNWMTY3fwG2xqeOaLzd511x0wT7cMxjbgVBLQujCj7B5aMgZQoTqDGOV2+zlu7Hk5pa0loNHIwPEwMUctHQPHz3cF3MrRwENN2LmdN3TspbYQATbOQlsAy/TS3SKRp//fUGVF+vHAGf1+zkDcn30ihP0i/ojcW/5wAACAASURBVFIu6zuMLdWfEsFIeR6FgOuGHk+X/ALuPfkULh40mCnPv0QopqeGJrsaryNQP1y/mZ+88yGWIT0dggISdeqSzAoCUFSncEe64JWZ/V0Bm6KxugIdnMQ9ttCUTscJg/vysyvOzpgTYDsPown7u3BeZCLuaEtARXDFX16gIRKhORrF8MmEOpL+5nHmJJPYHzmaxoDSjlw+tP05lw8GL26bEa9958Jm40RZULOaUzsdT9ho8qx/CBAyGmmMrSJiVDnUygQsGWZb4z8pL77liM3fPs8xAdteHBPE7YAi/CkP6dCi0zGlzsw9jxG1QoCgU2AwVdFGBHpK8IRfKea44uFc2v18eubaqSBP6zwQ06O8uk+oXFo+mvoWeGVjasKZmGWyramOx1Yt4HujJwJw1ZARPLrsc2KWmRCcEvIUP0HTxw0vvcKOugbK8vP4wcTT+aRyGzM2brJ5v1mYC68uXc0lw1rR9tLtto7WK6OgylQzhRSQvPoVjhAX9o+TMl6yow+ZEIDCsesW5GTX6pvDsRR7qJC2I1CqmYq6KSXbq+vtS1AcjVwBy0fiaRDuH4GiS4QlGFneFb+mcfHgwVw8aDAB7cg+OrvD+z33x0yd3WE773TvvOH4at5Ct1Kdlwoq/fNHETH2kG3RGzPrDut803Es+9qB4ZggPkiMKJ7E8KIziVlhNMWPKjR2h3cxvepttrZsoWOgE+d3uZDBhUMxLJMVdVtZsP9TtjbX8tn+TRRqAep0CyklJpJc1U/nYCHfHHw2k970ruhtSskbW1fHBXFRMMhbU67jBx/PZP6u7bYQNgKYEYsnFy6Ja5i76ptYtnMPFw4dxEdfu5lrnnmZ6pDDKnC0vvgjI2Dehq3eFy0dBkbyd1czTvsLjp01YUpO2M+TjcMeDru4WdhpF/RrXHJiZj0+F8f37krMcNTnJOVPZPB9k+aF3VZRbFqbqjuKftoTIaQAE564+BKKcg6d4dAeRE0dvyikJRpCEZKAz4jXS/WrPnrldQGgT94Iugb7sju8ybYTAwKFgJrDyR0vRch6JN4ac56v/IhfhzwmiNuNY4L4ECCEIKAmkux0y+nO1L53prRZUbeVe5c+TYuhEzNds4V9g/qESoE/jxNL+jC+8wDO6zoCU0r2h1uynjOWFlbcq6iYf118Jbpp8u133uOjTZvRLSsuhJMfhWlrNzCxfx++dfp4fvLOR57jW5akOhROU1EdOIEP6U62bI9b3OyR3MhDExde58IW6gGfxsVjh3Fi/x6ZDRwU5QY5tX9vZq/ckjLvbP62lHeABUK1hbFwLTxpT0UAhdqWyBciiGujzdw8/zFqok1ELR8gCRs+CgJRgioU+/I5scResQghuKH8Z3y6/3WW1s/EsKL0zx9NWaAT/6r8OhGziT4+PwWqSbziK6CIIANKvnPEr+UYa6L9OCaIjyAa9RD3LHmSiGVgWpmGSF2aNOohZu7czKubN/LbnE/45rAJrRbIrGuJMPQff2Jyv4H8YPwESpxsa6YlmbU5qcAn3gLy97PnMePOm/ndjHk0RdPyNju2VcURkMkzUByH2gE/Wq56m+SoE1bq93i7pE0BhvYu44ErzmRE7y4pQ0Z1gxdmL+X9xRuobgoRMQxaorGMaMF4XbvkSafZrJM1byHt67SShLkAYlhc+PfnGFfeg19deA5di45c7brfrZvG3khDkunKnkhzNMDYbr24f8h1cQYNgE/xM7HsGiaWXQPA59X/4bPqf8VD8LfqxXSTKh21FsAkR+vOgJL76ZR7xhG7BrDvo2OmifbjmCA+Qtgfqecfm98natmUAvumzLwxDWmiyzDgZ0+4iV8s+4BhnTqxat++VCKBu8yPKITQeXPjWj6v2smMq28mqGmEDT2R8L4V6tW+lhYCmsa0u27k6n+8xN5GO3RbcXioIkk2C8cU4Wq2KWjvM5beL1lTz+LYkyr4/Rq/uO5c+nZJ5c7OW7OV7zzxDjHDxC0OIiHBpU6al3Cdfe3gBgnsih1ooHvw7QzLYsHWHVz19EvMvOsWgr7sj862hnp+Nm8Wn+yoRBGCc/sM4MennkHnXDs8e3+4hdk7NyGBM3r0o3OOnSRISsnsPas9/QdB1c+VPc6lxJ+dsWNKnQU1L8WFMNi22l1GIXvNjtw54EUC6hdVAFUkKR/H0Ba+dIJYShMrOhsrthChdETNuQyhZoalHvz4kkc3vcG7u+cTNZWE2054c1NtqlpCeoRNnd3ROvoVlrKjpYGIaUflyagCeuLGNkzJ7qYmpm/ewOWDhlEcDNIpP4/djU2tCsnO+fZDX1aQz5x7v8aqXXvYuK+GT9ZuZubKzZld0yloSfNObtMaFAG9SzuwfX+dZ572dIVVMeHO80/KEML7G5r57j/eiduDk4W5dCl0MvFXONq3FCB9HidOmaPgD1dNxufX+OsnC9iwb3+8jp4LU0qaozHeX7eRS4/zZk1Uh1q45NV/0RiLxh2o723ewOI9u5h17S28vHkFDy2Z7RRFhQcXzuC+UROZOtTOEphendtFxDSIZSm55aJZr0Fm6a8IlSaj5gsUxMdsxAeCL9UrS1ot6NWXYNTfg9XyFGbTH4nsnUBT4x8JRT5FZqECHQg+3LuY96sWoksDK8lRoooklS8NuplKeQsZMV4671oen3g53xs1kS5KkSOEU9fvhmnxTsUGwLYX/uSsMwgmefPTzxbQVG4ffyLNkSiWJanYU838DduYvaKCVVv3oMbVywTiTjiPLasATrYBW6DGoKamBWJk5JHIJpTXV+7LGPbdheuI6abned08EYBty3Z4yoppJ5tXomRwlZOHuWLMcM4ZPpAzBvbltalfoW+pd/RZSNdZW5U5NxfPrl5mJ2VKelMZUtIQifDY8oU8vGQOUdMkZOiEDZ2oZfK7ZR+zorqKiKUDwvuFjaQ0kF0bBsjRirDSqGouTGmQ9wVF1MExHvGB4kulERtNf0QamwDbw9xstVAnDWj8DYh8BApdSh8nLzjxoM/x6o45RCzXg52QOkKAIiRJWS6RUhCNqVhpSzgJFPiCTOzel4nd+/LSstVZziaoam6Kf5vUvx9PXnEpv/t4Hhv3V2PoFpYl40ELIzqV8Yfpc3n4rTkIIZCmhRnzyKgRpzl4++wgTRhbSX1I/BW6rZFaQEsklhi7LUiYvXwTW6pq6Ns1oRVv31/v2d09rWLZEXkuOyNZQXaDO6QTRyOT5lqam8NPLp2UMmZ5aQc27qvOOF+OT6N3SXHWqS/YtcMzT3PI0Hl783p0j5wiMdPkhQ3L+MGJExGoSJzq2EmrKJ+iobehEfuVHAYVTmRj48dxFgWAKjTK/MW8ue16LGnQO/90RnWcSq7WsdXxDgnSewV4DN74UmnEVuQNXCEckxZ10kgob7IZSzZSVXMrunHwJfMa9Ob4Z4HAtITDDJBoioVPMRFIdEMlFPajG6nvQilts8P6uoTW1b0ge26LDsGEJ19KydyNlWzcuR+foeCzFAaUlPKnyy7kkgGDWb99H6GojmFZ6KaJISXp1WxcAZsX8BH0aQlbqEsNM5zNiYjzKwoBv5LIXOYGbLif0yfczofTsiRzV6bS6Ab16JTJY06D8PjrbqoBOU5WNeE4JXNVjV9feS5C2CsM184+9eQxnlxhVVG4aMTgrOfvUVDkmfzHp6goCp45MCwk1ZEWinw5dAoWYjmvcDfNsYVAERr9CsqyX7iDs7vcTXneaFThI6DkoQofHVSDmLGLsFlL1GqkovE93tp2CxGzoc3xDgXHioe2H18qQUySltBoGZ7Ps5QmjaF/H/Qphhf1xc1bJoStbZpSxbQELVEfTeEAoWgAw1QRSkJjdsOapQTTkPxxVaK+6tVDRuBTMv+rAqrKpQMTwRcvLl7BC4uXEzVMmqMxIobB5v01/GbGJ0xbsZ5IzEgVZAJQSeSRcPYHfRpXjzueuQ/ewcmDe9tX42RRS9GEHeFc6s/DZwk7ZNmwNeFsDAt7LGmHIiKRUmbamyWoqoKWFn581sgBCfNDlrGzafAubjxlNH06diA/4OP4Xl159JZLCUV1zn3oKUY+8CfGP/gof3n/M/I0H/kiqeq1hHy/n2evv4LCYDDr+DcfNwq/mhldqSqCKwcPJ0fLzD+co/o4o3s/hBA8MOwigoofiYKFgkQhqPq5e9DZ7cpd7FMCXNrzp9za72ku7vEjzi67BQUrxUwmMYlZzayvf7PN8Q4W9otEtHv7suOoEsRSSmT4LazqKVj7z8Jq+AXS3BM/rgQm4F6ytxgGiKEbrdRjawM3lp9HwHlghIAcn44tcBQMU0Um/eRuWLOiWEgLLEMgTQWJYE3tHj7duY2Ptm3m1J69GFBSSiDpAQ+oKr0Ki7lkYEI7+/uni+I13lyYUrK7rgHLtDJst1gJ8wFJmyJgeM8ycv0+7r7gFHyKmiHg3M+6brG3tileWcRtp1gQ8KUJJCkRpkzYbWOO4HZVvzSa26RRA1K6z16+2U74k0Ur9mlKm0mXmpsiTLv/qyz8xV28cNc11DWH+eHLH7CrthEJNEdiPPvJEq7684vUt4TjaTsVHWTEZO3O1tNMHte5Cz8/bRI5mka+z0++30++z8+j51zEV4eOpktOPv6kits+RaFjTi5T+tkZ3E7rPIi/jr2JMSV96ODPZWhRdx464SquKR/f+oWlodDXmd55o2iIbcKQ4Yzjpoyxo2X+AY15YDiWBvNAcFTZiGXjDyH8LvHKzeGXkJF3oONbCLUrWsH3iEU/BdlCAJ2Yh2NDiFxyAu2rc+eFXnll/GnkPfxj89usbNhMsS/AuG4jqI0YvFlZ4W3jjN+H9gdpCGpaTG6f8RZgl+751ujxWKbk9Q1rsaTk0oFDmHrCGIKOhrVs5272Njd7ssykITHNzDO7QjiFfSAhFjM5bVA5AP26lDK2f08+XVvpMXFvRgXYmc1OHNSLxRt32Jq4ew6ZJtAlSAOkInHDx/yayjcvP5UuJake/sqqGnQjif+WbJcGrj9zFE9/tDgj4CQOSQYT4g/T58bLL7lwv0s/KWlCI7rJU3MXc9XY4zyvuTYU5sNNm4gYBq9d+hX2hptRhcK47j3iVTvenHwTf1n5KW9VrgUJF5YP4VvHn0KuLxHCPaqknCdOutXzHAeKoNoBBQ2LTPtyjnpka+UdsxG3H0eNIJbGJgi/AyQHKRggm5DNf0UU/Qqh9cDf6X2MlqcojMyiObYBmVJGQkVViijIufSQ5tInvyu/Pv72jP1R4zVm7FrrSVGSbn05CTKsYSJpthKmlL8snc+T517GXWNOyui7oHIHt/37TfsqUsLG7L9mzNMNH89slgzXsaUlaW19u5Qwf922zERArdhrY4ZJj85FnDSkF0+8u5BwLIYRMbPS4xQL/H6FU0/oy+2XnEzfbqnUtRdnLuWVWSvic5TpSYMkPDN9sV1nTtjOuCQZCtIOlT57ZCINpWFa7K5t9L4Ad9y0Cde0ZCacB3h77Tq+/8EMFKFgWRYIwTXHjeBHZ05MyYNRFAjyoxMn8aMTJ3mO016Y0mLark94e/fHtBhhhhf158byC+iVl1qlfEDhZFbX/ZuUXKmAJoIM7XDFIc2hLRwzObQfR8w0IYToKYSYLYRYJ4RYI4T4lkebiUKIBiHEcmd78KBPGM22zDIhOidxTrUzvsLvk9t5Jr3KZpMbOB37Z9DIzzmPnp2noyh2tFrUbKZJ34slWzFMep1RWqysr2RRTQVhMyFMf3jceZTlFMYrNQScSg0d1WJyVD8FvgA+05ciBF2EDYMnVi7yPN8vP5hNJK0ApitAfIrwrhzhIYDdzbIkdzz+GhW77eQy0aiRvTxTlmctN+BjzMCefOWsUcz6/R3M/M3tlBSkhQinZUeLxUxmfV7B7MUbU5ot27iTR1+fh2FYOCFbCMs2cwhTJhyEOE5CR7jHucTOOToX5jF2YCJUWlUEecFWUoSmQQKFOQF+MW0WszdswXRq++1ubOT7H8wkapiEdZ2oaRIxDF5cuZIHZszg0+3bE8E2h4iGWIjaaDN/2PA8z1ZOY0+khiYjxIKaVXx72R/Y1lKV0r7Q351Ty76HKgL4RC6aCKIKP8eVXE+33NGHZU5ecPnxx2zE7cOR1IgN4DtSyqVCiAJgiRBippRybVq7uVLKCw/5bCKP1FIVyce8cwT4ff3o3uml+EPiai4Rs5FZVY+wPbQIBQVNCXJypzsZXHRum9NYVV/J91c8T9TUHUedxd0DL+TSnidREshj+lnf4IPda1lWs4OuuUVM6jKYd7Zu4O3KdQRVlbKiAmZt3YqXhNudRFVzYVgWFftrslw3jO/bm+Ubd9ES0zOOZePyAizesovrfvcipw4uZ/7qSrwiMYQETQGfqhHTExngfJpC19JCTj+uL2BHrBXmBRk1sAcfLamwO7dy7sffmE9TS5Q+XUs5fVQ/Xpy5lGjMDmzByOxjKTY90E2xKQHUNNuFhOraZh57Zz53X3qqfW4huO6UkTz7yZIU84SqCIJ+HzHVJOqYQtzVxr7mFl5cuII3l61lYFlHnrn5Ct5au87WgklcmlQhKk1eXbuGdys20rOwiBeuvJLiYDBrSaXWsL2lmp+ufIX1jS6jRyffb+Ca4SWSqBXj2a3v8ODw21L69is8hx5549nZMh9T6vTIG3dkqWsOjtl+248jJoillFVAlfO5SQixDugOpAviw4PgWdD4U68DkHNtq12Tl45SSt7ZcR810S1YGFiAYUb5ZO//EVQLKc/P7jRp1EPcu/QpQmZqbbq/bJxGeX5nTujQF7+qcVHP47io53HURcJMnvZPaiNhog5HtEKpQQuAkZYGQhMK47r2zDinKgQBTcvUiIFcn49Lhg/GClss2rozUZ3ZvdZWbLwAUd1k7uqtSFPa5fGS2RYO/Suoaugxk26lBdQ0h/FrKpPHDeHOi8djmCa79zdQUpRLXtBPRaWT2rEt5VDCC+8vRQAPPfshpR3y7C7JrI0kKE70HMJe2ygGWIbdWGqJ9lHd5N+zl3P7BSfhd2h5d559Ensamnhv+Qa7grRuoAiF0pxcOhTmsL5mPyHdsDm9EHdKhmI666r28+xnS6m3InaOD3f6SeHWEjsIZENNNWP+/hiKBqf3KufnEyfRo7DtUkkAzUaEWxc8TqMeJlG6S6E+mkNJMITqsG8kktUNmz3HCKgF9Cs8p13nO1w4ZiNuP74Q1oQQohy76PlCj8PjhRArhBDvCSGy5joUQtwmhFgshFi8f39mrlahFELR74Ggsym2Juwfjci7sd1z3RtZR11sR4Zzw5BRPq9+utW+M6qWe/JEI5bOi5WfZOx/fM1CqiOhuBAGO++wkWa8FUBA07j9hFQnYswweGjmx+geAQRC2hFtD772IYsqd6bkK46zJtoB3bSDQtx5CBJLfYkkHNUxTIuaumZOH1xOLiqvz1zOlPv/yaQ7H+WGB//FeXc/zrf/8AbV9c02ta0NLnAyLEtSXduM1pYWmWSOQDq5fqTDyEhpJqltSrAINFXhV1efy/Tv3Uy3okIUSxCLGuyormf99n109eXzjTNOSnlZu4gaBq8tXcMp5b3J9fncaRD/sdKnKG2n6cfbK7nkPy/QGG29CKqL93ctJ2rqpNdPBGjRU00redoXk6qzPThmmmg/jrizTgiRD7wG3COlTPeMLAV6SymbhRCTgTeBAeljAEgpnwCeABgzZoznY6zknI0MzIHwdJCN4B8LvtGeD1E21MW2IaUVJ9ODI3wENMR2tdp3T6Quo6qCi6pIbca+97Zt8Iy0Auws64Zdrujk7r34ycln0rMgVYO69433+GRzZYbwD2gqAaliRiyiXhWXDecNrACmh0/KEdQC+0CK0yveRqYI82jE5KPFG+M5iGv1EALiLIfP12zHsqyEHRfwSEjnabKQ0tFwlVa4yUl9458Vey7JFisBdEi3VQMbd1ezs7rBzmPhIGaY7Glo5sk5i1JfZEmD6abJqeW9Gdq5M6v37iXssTJJgWWbUkJ6jN8smMvE8j6MLuueEpiTjvWNu53w53QIoqZKSNfI0QyCqo+LumeWkvpvQHJMwB4IjqggFkL4sIXwC1LK19OPJwtmKeV0IcSjQoiOUsrqgz6nUgJ51x9sdwq0MgzplhRy9T5bGBT4W49sGlrUkxzVn+KgA1BRGFFUDkCTHuWNrav4fP92ms0wnq75+MVIAqpKJy2P6155FVNanNt/APeOP5lwTOfjzVvjNsxkFAaD9AoUsGLHHo9BsROmO0I0xTzh/nVLGQE+TWVIr05s2lWdSUOzUvvFA0M8rshIoo3Fo94s7Mi+dCnv9Zp1bNQuGyK9uee+ZHMKNmviqgknEEjLnLazpoGHXvmISFhPEDGc1B5R3bDPnaR4xq3PEoZ27YwiBM9eNYUnP1/MHz/7zIMUaS8hXPOGlJKw0Hlp4wre3LIW3TL5+gnj+NboU1J6VUeaqWyupTRQQEDxebzk7YChmKURkApjSoZySfeJGWdv0mtYWPMO21pWU+TrzEkdL6ZHbvbowMOFw22ZEEKcB/wJ+9X6pJTy4bTjAeA5YDRQA1wtpawUQpQCrwInAs9IKe9K6jMaeAbIAaYD35KHy7N6ADhigljYauhTwDop5R+ytOkC7JVSSiHEWGwdJovn6YtBXXRnkhBO/guDis5rte9pnYbSwZ9PLFKfksrQr2pcVz6B3S2NXDbzn7ToMcKmjopA9UlMQyGjFLLDqos1S6Zt2BjXyF5bu4Y5W7fwwPjT8amqpyDe39xCB5mdDZAiuAR0yMvh/otP57V5q1i7fa+TutNethflBXjk1gu464+vsb26AdOyPGvBHRCc5YaQ9nVKBYQT1usKrPQJC4nt/vUob9/ahaqaIBDwYVqSKaeO4K5LU4VdTVOIr/zuRRpDkRQ2XPwlIUjJD5J+VyzeshPDtAhoGid060quFqDJiCblQZYpNfHiUzcEpiJp1u2X9uMrFjG4tDPnlg8gahp8f/E0Zuxch1/ViJk6+XneKyfbPiwo8XfhB0Mza9DVRHfx1ObvossYptTZFa6gomkR53adyqiStp3PBw15eOlrQggV+BtwNrATWCSEeDvN+X8rUCel7C+EuAZ4BLgaiAA/BoY7WzIeA24DFmAL4vOA9w7bxNuJI2kjPgW4ATgziZ42WQhxhxDiDqfNFcBqIcQK4M/ANQfyNpJStyPpaqdi1d2JjMzMmgawvVjf+D7e73JB1Gz22J+AT9F4Yuw3GFFcHt8XVALc1u98uueW8tMlH1AbCRE2bc3GdKSZqjmSzdUoDft8mLYKmJLJy7JoiEZZvq8q7jjyguZT0TzCooFE1WQJmhToUYNnZi3hd7deyNcnn0x55w50Kc5n4rC+/PTac3hp5hK276lD6pYdxnyQQtgOjpAptDUB8YrQikzIrgy4x43E3AEKcgOtmivOOX4gN5wxmt9OvYB7ppyOmvabvPTJMsLJRVWT+iLtl5HQyPriiZkmH2/YAtgBHSBRLJH4jTPf5whEIpLRQdjQeXy57UL59YqZzNy1nqhl0qRHiVoWLeEcNFQSN4lEVaz4SytspK7CXHxQ9Q8iVggznllQossoH1Q9SczMjLg7rJAHsLWNscAmKeUWKWUM+DdwSVqbS4Bnnc+vApOEEEJK2SKlnIctkOMQQnQFCqWU8x258xxwaEEEB4kjyZqYRxvPq5Tyr8BfD278GLL2JtDX4kbSydh88E+E4v87ILtwyritHmv7jllaU8nymioilm2YjGDyp/UzUNCYU7UZy2OMoKbRJ78j66trMAwZ146z5VWIGAbra6rpVlTA5uo027NzY2+pryU34KMxHE09ZqXybKUlCZk6W/fUcsVDz9PUGMEyJYoULGjYxmcrK4lE9VTh29rP4Kzb080FAZ/K4PIy1mzYjYn0kk/xYJJkRSrgV4k6gSCukHZLGikCbjh3DI++8WnGNNyk8R8sstOE5gR85OcEePQ7U+iTFCyycOOOFLtw8lxUIZg0oj8fVmyyQ8Q9ENEN7nn5Xc4a0o+7zz45zkwR0hbGltbKW8utIOJgb6iZiKnzWuUKomZatJ8hEREfpflW3Lnr3uIKglEl/TxPsaV5BV7/YYpQ2RZaw4CCMVkmd+g4QI24oxBicdL3Jxy/kIvuQHLugZ3AuLQx4m2klIYQogEoBbKZOrs74ySP2f1AJn248L+bayI8LUUIAyBDEJsNsQUHPezgwrPRRCBjvyb89Cs43bNPo97Cy9tm8eCqp3lo3b+JySjJRKuIpfPnDe9nFeSaULh/zATGl5XHgz00RUFVFE/OqQA65eXy/bNOtxMMpWkXQtqUvCe+epntp3IFsGFTu1wnnHsIbE27tiWMYUo774WUhKK6bRcWAqk4ws3V9JK25CxrqiLIydFQFTsZvqYqqIrgzBMH8Jf7ptjpHTMuKLFH4GjHlh3RZ8UshwFhG3yFsylOYMc/X1+AqohMR10awlGd6vpmvv771+KBGABdOhR4yklFEUwZP5zf3XgBv7l6sl29wwMS2/49e8NWXl64ksmDBqbkhG6voVQRgjFl3amLhrPK7ZihEDKsuPMYbO06qPq5ue9Znn2EyP6Iq+LI+uqTE1m1tQHVUsoxSdsTacN5/Szpv2572hxK+yOG/1lBLMNvkSKE4wciyMjBm3iGFl9AaaAPmkhk2NJEkMFF59I5ODCj/a7Qfm5a8BDPVn7Ap9WrsQhR4I+iKalalkQysrRbPDNb6jEY17k3z51/BU+eexlTR4zh7pHjefqiyz0zeQU1jRuOH8mont0JCjURWWYllvd+ofLw2x+DJVBidpVipR0150Q2y06Scy7xikmFqgjOOnEg373uTIqDAdAlZsTEilrMnLee5et32kIzY+zMe19TFXp37YCqtn6LxmIGVkSmvoyyTFJi50Vesn4H++ubqWsKc92EkRnOOwC/qnLrWWMBOGf4AF6/63py/b7UVUHSbxI1yT5vYQAAIABJREFUDF5ZvIpfnnMW95w6ni4F+eT4NMoLilOSNbkQiBQ2h09RuGnYKDoG89CEd2CSKSUtUR8RQ0VKgYLCqZ2G8OS4u+iRW+rZZ0jheJQsgU69c7NXxj5U2E7Jw0pf2wkkE+l7AOn5auNthBAaUARk0pVS2ydXpfUa8wvB/26uiVbe9Fkj7NoBTfFzee8/salxDhWNc/ApQYYWT6ZH7ijP9n/Y8ApNRoJo72oqub4YjdEgrjQwpMX9x0/ktrmvEXEqM6hC4FNUHho7OZ4U5uTuvTm5e+/4+L84YxI/mvURmmI7s0zL4pvjTuLE7vYK6saTRvL8wmUpWdcCqorRYrKyvqo1TkZWeNpcrcxjKULJ1ZBNePX9pdQ3pGp2lim597evc9ro/sxdujnOTc4GTVUoKcxzssZlbxu/vrTq0jLLnW1ZFj966n2awlEkMKhnJ246cwzPzFqE5ghMKSUP3Xg+XUsSFTEGdulIv9ISVu/emxD27l+HIqebFoZlMXXsGKaOtZf8lpR8d8Z7vL+5AiklmqJgSRhf3oNPq7YRtuyIQVVRuPbdl5ncdyBTB53E39d/FvcluCezbcKCmOEjZtjpM6/ueQa98zpjWCaqUDJMcud2ncqO0HpCRiO6jKAKHwoKU3rej6q0nVbzoCHJdEAfGhYBA4QQfYBdwDXAV9LavA3cBMzH9j/Nas3nJKWsEkI0CSFOwo5xuBH4y+GcdHvxPyuIRc4UpL4U0lP8iSAi56JDGlsVPgYVnc2gorNbbRfSI6xqqEBx+F8SN6xTODZGiSkFCoKBBV0Y06k3MyffzoublvH5/u30zi/mhgFjGFScvWbelGHDOKtfP2ZXbsUwLSaUl9MpLy9+/NtnnkJJbg7/+HQRNS1huhYW0LegAws3bk8IJkGmScC5PVOcY1biUPoj1KqDznGkSSn56PONtvAUmX0sC3p16UBxQQ6hcIxIzEBVBaqi0KOsmC27al1VikhI582ZK1IqabQ6Aec3T7kmj/aRmGFzfR2BtaZyDzv31/POj29m9fa9+DSFsQN6EfSnPhqb9tawaW+Nd55lC6Rqs09y/anCTRGCP5w7ma/X1jB/5w4K/AHO7tuPPL+f78/9gDcq1hIxDUKGLXTf31qBTwzmnuETeHTtPEJmDMOyUFQLTU1druiWxVs75/PI+ufZG6kjVwtyRY/TuKHPWfF8JXlaMd8Y8ChrGuaxvWUtxf7OHN9hEoU+bw36cOJwksAcm+9dwAfYmtbTUso1QoifA4ullG9js7SeF0JswtaEr3H7CyEqgULAL4S4FDjHYVzcSYK+9h7/BcYEgPgvUOYOGWPGjJGLFi1E1t8Jsc9t2zACO5z5MpSinx7xOUgp+eGqx1lcuyGuBbs/pekst6JGLgo+8rQcTu4wgnX1++iZV8xNA8YyrEPX7IMD2xvqaY7FGFBSis9jaesFS0oUITjtZ49T25Jma3SYBnHabppt19VqFccGnCq0pZM32ENAO30zHItSZlTokMDQfmX8+ftX8s7Hq1m8ehulxXmcd8pQ7v31a8R0M05hS+7otS/lGMQrjbgaoRRgqal9VEVgSolMM4/k+DW+dcXpXDnx+MwTOJizbgvfe/k9miOZ7ASJrYHffPIo7p88IesYyWjRY4x6/m8ZTjmwVzSLr/8GeT4/zXqUWz59mg1NmXmQ832SvEAUIykpVUDxMansBO4fenW75tEWhBBLpJQH7NEL9O0uu//yG+1uv/W6Hx7Uef5/gBDi3nY0a5FS/j3bwf9djVioUPw4xOYiw9NB+BA5l4Dvi/m/XNtYyer6LSnasBB24UdFSAJqkFv7nIdfBHlo+WxerltOzDJZWr2T93au45ejL+CS3iMyxt1aX8fXp79NZUM9qrC1xZ+dfiaXDh6KaVkoQmRlhLiOvaZwNFNmuVF0SUlz0lkQwrRVjeSoQrelFHa+iXRIsrM74pEPSV8Nw8KnKazbUMXiZdtRFMHMj9djmlZWLTb1ZKlf42O7yqIiQQg7tabpRO8J8PtU8vMC1DRlprEMxwwqdibC5muaQjz+3nw+XF6BqipceOJQJo8ZlMiFnGVu26rrW5l8KvaHWlCz/D9qisq+UAsxWc/f1n7KjoYYuu5H0XRUNXHVfl8kI6Vq1NKZuXcZt/Y7n1zNx5bmrQTVIH3yylFaNecdboh4atcvAe7D5iO3dsF3AEefIAbHIxyYgAi0Tws5nJi1dxGGjKZ4OyUSSwgEgh8Pu4FxpUP56scv0KxHk1b/kohp8ODS6ZzbY3BK+ZuoYXDVq/+mJhxKETIPzJzB7+d8xp7GJnJ8Pq45fgTfOf0Uz5pqAPlBP/WhtDwGls2YAG8TBU7F42Rflwt3uX3eiYOYuXADMd0ubpkT8BGL6OjtTVwB9Cgr5oKpjxGKtL9itks/zhDsHs64ZGHtCmOwbcMNMoKiKBkpPYM+jT5OkdLGUIRrfvMCtU2hOBXthTlLmbdmK+P69WTextS8zPHfS0JjJC1TUyvokpeflUVjWhbbW2q5+7M3iJqGQ3kUYPrID0KOX+ATAkW0eI7gFxqvbH+XJQ2foAoVKS1y1VzuGXg3vfN6e/Q4ApAHTF/7X8bzUsqft9ZACJHX2vH/WdbEfxMRM8asfQsRgtQNeyvP7cq40qFYUjJ/f6Xnw6Kg8N729czdvZVdzXak94wtmwgbqcEFmKCHLaoam5DYmbxeXL6Sb709Pev8rjzpuHjlZhfCSwgnH89ioRJAcX6QX95yHvv2NxIJxTCiFmbMorkxih5zSzAl5Qd2cgSnX7hfU/ls8ZaEEJYeW2vza6Ndir3bhdPesiRS9+6oaQoXnGTX/nv101U0hMIpmepihsnOmgYmDxvE2H49U6YOgGIL87OH9c9+AcDW2jpeX7OWTyor0RSVrw4bRU7ayzRH07hh6An8YtlMwqaexjsXGLqP34yawkfn3EeOmkmzBIhJnc9q5xKzYoTNMBErSq1ex8Prf0fUbP/L4pDh9f+bbfsfhpTy/kNt8z+tEf+3sKBmlScNTTiMpCt6nmF/xybbewVxhI0Y3/vsPQL4iVkGE7r3ZUheGWE9VVNUdJHkhrIRMQzmVW5jS00tfUtLMsa+Y9I4llfuZvXOvYSj9nhZnW2OlulZcdk+xO7qRh54bBqmYSXsx8kPkJRxQS6S+gns3MSqUDBiJnrETBzMAuE4vlIpEPZnTRGYpmyfMz5pPnFN2ZJ2ikzXnqxAl5IC/vD1SyjMs+mKc9duIapnmiDCMZ1FFTt44pbLuO7xl1lftY+Ybv8YflWlc0EeU8akR8/aMCyLe959l1lbtsSZDTmaxjNXTMGnqDy1ejGmZdv3bx4+ipuHj+L5dz73HEsTCsX+QvyqxuU9T+GV7XNTclCoKOSoAiEyBa4pTRbVLeHUjie34wc8HPjSaMQAODktfoodVSyBecDPpZRtpm04JogPAnWxhhQHSTL8isbpnUby3q5VfFi1ji65+exuacoQxqaU6LpFzCnt9PGurTSXxsjx+WhJFsZZhJaqCNbu2+8piAM+jadvv4Ll26q466k3aQxl0YIkCSdcG1pJPGmPIB6d536VaUI4/lmCoVuYluXpQc/Kpjdx32LxnYU5AULRWOIF4OG/lBkfkubo7JeGJE7TNaGpPkx+TiIvR4f8XI9Z2ahrCWOaFgM6lbJu+15UCdKCId078ejNl5AX8M7v8fjCz5m9xU3QZN83LbEYt7z2Oi9dcxW98zvg11Qm9e5Hrs9Hix7LvAh3ytIiz6lT+NU+57Iv0sCcfSvwCQ1TmvTKKyOo7aLBIwlczIpRG2uNVnuY8T+u6R4E/g18Akxxvl8HvAx4R9sk4ZggPggMKihHE2qGMBYIRhYP5quf/pPNTftsHqgUSKGhoWBIC5+i2HzTaKpLP2oaLKnZSWmwkIhheOY1ToGEsvzsZichBCPLu/G9iyfyi1c+zEwOJB2bsaspe1HcIEXbdS4y7vhrk1kmbEF1oA9kvKqzlWBBNDVH42kwBUmJeFpTukTqR8eCYl+PcyxmmLzwwRLuu+5MAK457QQ+XVeZyDSXhPkbtnH9X19mS3VtSp6Piqpqnp6zhO9c4J2C8rnlyz0T99eGw5z9wjP4faodIafN5rmLpzC0Y2fGdy7n071bU+4DAXTNLaRvgW3P1hSVHwy7ltv6T2ZzcxWdA8X0ye/C3zY9xqLaugwbdEDx0zv3C7IRw5dREJdIKX+R9P2XDlWuTRyVNmIpDWR0ATIyC2m135PdXgwp7EPf/B74lNT3mF/xUax1p6JxX4KMLyR+n46mmpzVbSBTeo/Er+cgTQVpkdikzXp4bPJFnNyjFz5FIaCqFOYHMqLrFCEozctlTI/Ww+KbwlG6lhTyldNGeghYEkIY4hIuoVVK3AQ9XtqyTLtzPJ+51kwQ7dgvkueR1sGNJCRd0LfBunCDP9w+hmmxanOiztvYgT25ZdKJyV3iW9SyWLt7n2fV55c+W+6d+xloinqvSAzLwjAtWnSdZj1GdTjE9W+9im6aPDLuQrrkFpKn2Vp2ruajyJ/Do6dOyWDNdAwUMa50MH3yuwBwSbeL8KUFa2hCpdRfyoiitqPpTKuRfQ1/pmLPIWRnk9gcwvZuRwdmCyGuEUIoznYV8G57Oh51GrGMLUPW3QHEsCVLDJl/N0p+ZlXlg4UQgl+M+DrPVU5j5p4FRK0YQwr6MLXfZXxv8bSMvLFC2BnWRnfuwlfKT+LlNavJSBInQY9JHl3yOd2LCnl2zBT6dyilJCeHX86aw8srVuNXVSwp6VqQz5NXXJaVxla5r5YHX5nJ8srd+DUNLEnQr6VoeZ6mCIdkrKkKimGbTrLaldO/ZxO6WQgVEplh+waQUrYqS1Om4Gi3EuySSM5nJ9lGZp/kF41FPPquYnc1Dz3/IbdfcjIlhblcf8YoHv9gPnF/XbKZpBXUtoTpWlyQsX9EWRlLdmdGzkoy7d0x0+STHZVMKu/HRxfcwUe7KtjYsJ8eecWc33MwOVqqgJVSsjfSQFD1Uey3V0g9cnvwvcHf5fnKF9gW2o4qVMaWjOH63l9pk8JmWo1s2nM+urkHyaE59v4HQxQOCkKIJhJejXuBfzmHFKAZ+ElbYxxVglhazci6W0C2pB5oeRSpDUQEzzhs5wqqfm7rdzm39bs8dQ6tqIFSQq7Pj1/xEU1LHo8EHYv3t1SgIHh9w1ruHXsyt48ay0/OOpO7xp/E6r376JiXy9DOnbIK4TcWreZnr30Ut+m62ls82U+yE8wLAoIBH/26dWDNlj02VSvulMsiwIVt18hQXNuR28Lj9N7IMm9X8XIFvnBMGlKVdnq25LbOGCnvDWFXEXlr3mrmrtzCf352E4GAhqaqRKXZit0lEyV5iSobUkpW7d7LgsrtjOrcjTX79mWYJ6RChoC3pEV1yOY6+xSV83oO5rye3kncP9u/gV+vfpMGvQVLSoYW9eDnx19F15wO9M/vx8+GP4hh2TX42sshrml65rAIYeBLY5qQUma+fQ8QR5UgJjKdTFUTkGFky5OHVRBnw0U9juPRDXNS6tAB+ITCmV0Hs6m+Jp4MPAWudFDsS4iaJo8smMfk/oPoWVhEaV4uE/qWt3ru2uYQv3x9Vko1DHdcqTiBF45Q8bQHY7ft162UUwf2Zt2WPQmtMKW9dARf6mApgR2e9ub4P6mf2wMnUk/RlLh9NlmYJv2xZbbpvBQdYeypnSVN0DAt9tc3c+Z3HqV7p2KK/UGqoy2YrrB0BbiV+O4ioKl85eRE5Q/DsvjmK9P4bOs2YoaJT1MRSAaUlbCzsZGiYJD9sRZMj7eaJWFUl25t/hxrG3bywLIXU0oorarfztQFj/PGhPvwO2YzTTmwR7wh/M7hEcJwNJkc2g0hxOXAqdi34Vwp5Zvt6Xd02YitfaTlfk46lhkieqCQUrK0biW/Wf8XfrrmEaZXzSRspp7v2j7jKM/vSI4TqCFwkrP0GUu/gs5UtTS1Ln6SHk5LSh6Zn1l0NBtmr93ina5REK82kRFznLapiuC2C07ipRlLMQ0ZZ1SkjOponck5DJPpYimnSR4/6fvBaMo+VY1nmIuH5ovMy4p/dm3ByY49kd4oAUuCbkkq99dT3dASD4IRjlMzhZWRtEV1k+E9usTHeWnJSj7dso2wbjtdI7qBrltU7Wli3m23ccf4sQjV+xcY2rETA0razgPxzObMl72FpMWIMmfvmjb7Z4MisrNGDhTxe6cd29EAIcSj2BF0q4DVwB1CiL+1p+/RpRH7RoDIzTRNoIJv9CEP/0zlv/l4/2dELVtj2Nq8nRl75vDrET8kV7Nv4BzNzwunTeW9XauZuXst+b4AU3qPZmzHPgAM6tCxVZMqyWGhEhbs2pmtZQYM02yfXU5g07/SEpv5VYXJ44Zw4sCeNDS3XmFYuDS21hp5zEU4ZoyUNu2UyskhxgqOnydLGg7XDCPjX+y/mmrzeHVhZkxPurbgNLaFsMC0AC1J607rfP8L79Kn7HoGdOnIi4tXeLIkhICZ6yuYtmUDMY/K20gY0KF9yXg2Ne/1NIOFzBiVzZlVztuLkvzrCdetRaYn0zpQJL8AvzyYAAx3M74JIZ7FFspt4ugSxP7TQO0JxhZsZ50LEyIzsBpLEAXfRojs9dyyYUdoN3P2zyOWtBSMSZ3aWB3vVn3IlT0vju8PqD4u7TWSS3uNzBinc24+E3v0ZfbOLakHHC1TpC/n2kgXmYzTBvfhkbc/zjzgarDJcJ3VgngwR1lJAQ/ecDbNoSiKEBnUqZTOjlrrmjjWf/wk9bvXt3uuySguG8zQU2894H5CykQYbRZhHlQUfDkaLVEdS0osy2L04J4s31aVwXJIZ4IkQ5NgKQJXfKefzrQk//joc35z3WRCMe+yRYZl0RyNketLrJaShZWCIN/vHS2Xjj55ndgVqsmQdbmqn5557c+sdsEFFzB9evYozYPHUcWGaC82AL2Abc73nsDK9nQ8qkwTQiiIkhcg5zIg/YZugdC/kHV3HvC4lrSYX7MgpbKDC10afFbjHQWVDU+edTnd8wpSl7gGEHNtrsQf0IJAgPZmyOvWoZAbTh2ZGCPpr5I8dYnNA3aXho5A3lXTgGFZ/PrZD+P19OK0NpGu4Ajicd1w0EIYoH7v+kwTRjshkuvCpR/Dtv02t0SxTNuuLS1YtamKIb2ypB7N4gTNCzr3k8f83Gmv27UPgAn9+6B5mIhUReHkPr25dtgIcrXMXMB+TeXywUO855WGr/abiD+NoiYQBFQfZ5R5R/h54cgIYQcepq+s29GBUmCdEGKOEGIOsBboJIR4Wwjxdmsdjy6NGEAEQRsC4h2P/+AoxBYh9fUIX/vKiS+omcW03S9REzUws5QQ1g6w5MzGumpqwmlLPyesV1oWQipxO2pVUzOf797FuO49vIbKwKmD+/DivOV2onhXy04Swm5Ag2JmXolPU2kORflw0UZ7R7o92f0rvQ8BnDzlt+2ap4vPXrsvc2fygG0oVQLoWlpEXUuIcFIiIVWzSzShKRjpvN+YwdrNexLFPZ1zKBZYiswQxj5VIWzo9sspi+oigN6dOgDw9dPG8cG6CpqjsXjOihyfxqRB/RhU1pGBnUs5v/8Apm/aSMQwUITAp6rcPupEhnUqa/2CHYwo7sXPj7uSh9e+RcTUMaVFn7zO/PqEa1MSSbUXn2/r7bl/bO9tnvvbhaNHwLYXDx5sx6NKEEtpIeumQmwZWZ12CNBXQjsE8bK6z3h95zPoMoZPFWDkZ7TxCx9ndD7Fo3d2zK/anpEBzPZG2VqbSJp6zDR4a8PadgviHJ9mp8pMdlApxCtYSAGKx8rZr6lcMHYIHy2q8B7YtUYcBCWtPUgfM8Uxlu2EQqAoglFDenDCsB78572l1DWFKC3OY/zIvpR2yOMv//4kQdRIErqGYcVzM0s3yNE14SQJY5+mIhSISdNm6aUV/HRt0AG/xtQz7ECQLoUFvH3bDfz908/5eNNW8gMBrj/xBKacMMyZtuC3Z53H9SNOYMaWTfgUhQsGDGJgaccD+s3O6DKc08uGsqOlmhzVT1lO8QH1P+L4kgliKaWHXbB9OKoEMbFPQF9BdiEMCAXU7BUxkjG96j/o0pZaqpAUaBGaDLeWnSCgBCjP68nZZRMPaJqF/gCaohCzWslv60Bi2xZjpsnczZXsb27huG5dGNrF+xqG9igjPxggFE0KKnFZE9jasOUH1RHGQkDQ56Nft1K+c8UEXpyxNPtkRKpMFI437EgJ5hRhnHwA4oLSsiQfL6pg5vz1xJxkPdU1LezYXUffvp2JhPV4eyHJ4O4KsPM0q46lxXQccW4bU5JTFCDcHE7MK2mF4fcJAkE/D152JieUJ2hnZYX5PHj+mdmvTwhO6NKVE7q0XiCgNeiWwT8qZvHajoW0GFGGFHbnniGTOb6Dt3b7hcJ9638JIISYJqW88FDaHHFBLIQ4D/gT9uL7SSnlw2nHA8BzwGigBrhaSll5MOeSkY+wq3W0NqEc8J/arvFqY/tSvudpOn7FRLdy6JM3lHO6nM0JxcPbJMuvrN3N39fNZ3NjDUM7lHFD/zHeyoIEjNSbN9fnY2BxR078w6PxfBGaojC2Vw8ev/JiO3IuCYoi+PPNFzH18dcS1STS7MXJfhRVVRjcuxNPfvsqahtDrNpShSckqAKCAY1I1MDvUzFiJooi7KTuRwDJwjj+2dGQE/Q1QXMolvI2kEBzTGflhl3xvkibYyAskeGUExBPhh+3SjjDBzSNQV078fnmHXH+stvEr6k8fP35TBjWN2sVFcOymF2xhc3VtfQuKWbSwH6eBWEPBg8se5GF1ZviNLbVDTu46/OneWzcVIYX92yj95HH0UJLawdObcMGLIChrQ1wRAWxEEIF/gacjV0xdZEQ4m2nVpSLW4E6KWV/IcQ1wCPAwdV5EbnE1+EZUEHpjCh5CtEOm65hxSjyBWgxmtCliht461Ms8jSD63tfTo/cPm2O88GO9dy78C2ipoEEtjRVM2PnBu4Zcxp/XLzAdig5lTfyFD8R3SSM/WDlaj7GlHXjtzPnpTjsYqbJZ1u2MfH/niSoaeRoGg3NEVRF4bQBvXlg8kRm/GgqD78xm3eXrI+zH1wvvTATAsewLFZv28sjL37Eq7NXpmifKVxgoH+PTvTvXsrCFZU0NkWQliSTBHZ40apOleWgVLyPpQvzeHtsoSHdlUOSjTgc0zllYG/W7d5HSySG7rx0cvw+Jo8azFnHDcg6vT2NzVz73MvUh8OEdYMcn0ae389LN11Nz+Ki1q6sTWxu2svC6s0ZXOKIpfPXDR/w+LiphzT+YcGXRxBf0o423lQaB0daIx4LbJJSbgEQQvwbe9LJgvgS7ByeAK8CfxVCiNaqr2aDyLkMGXqJTNOEH/LvRuR9za7q0Qa2Ni/n1R2/xi8MFGcNH7J8hK0AKiplge4pQtiUFp/sW8N7VUuQUnJe11FMLBsBEn6weDqRpLpkppSETZ3/VC5j4TV3MmNbBY2xKOO79mJAcSnTKjbwwqoV1IRCDCrtyP6aUCZrwrCXx7W64/BzlUMTXl+6lreXr+flO67lV185j0kj+vPIG3PYU9eEdBx3Stp7SrGkLYQhw6bsJmQXEiq27Wfz9mqklEhT/tcoNwktWSQEq70jlTfs2Tm70VmQakcGO6jmzXmrefW71/PsnKV8snYrRbkBrj1tJJNHDWp1nve9/R57GpviL8KWmE5YN/jW6+/y+i3pBYgPDGvqd2S9zHUNuw5p7GM4MByKbdjFkRbE3YEdSd93AuOytXEqtTZg00CqkxsJIW4Dbkv63q4JnD+pgGmv3YXIu61dfUJGA69s/wW6jDrnsffnKjqSAD1yB3NT+bfi7S1p8YPlz7G4djMRyxbaS+u28O7uxUztcwF6FjtwVaiRmGVw5cDUunVbautYu28/ummyvb4BJWRPIFk7zXCYuaw3xT5mmBZfe/YN5j5wG02hKPVNYZCJUknpb7hYJJNCIRQ8C4ZaydnQviCNJ+U0Lm1YJH6XA5lGenuZdMAuNpp5j+yra2bHvgbuu3QC9106IeXYtuo6Fm7eQUEwwIQhfeNlperDEZburMpIZ2pJScX+aqoam+haePApCkqDBahZlIpi/+GLjjsUfIlME4eMIy2IvSRf+n9Pe9ogpXwCeAJAiPb/F7/3URNK0a/b25w1DZ94RiwJAf3yuhGyOvLNpd9DCMGYDiPplzeSJXUJIQwQMmLM31dJTegdYpZ3asSYZVLZVEennAQTY8WePTy9bElKVFZGlrLWrtwNsDChvi7EaT99nOZwFMuQcW0vhU3hsATi+92oN4cdoLTmiFMgS278ww53DqoiMPCYk/Da6Y2zThpExZ5qtu6qTRHCKX/TYFqSrXtq6NutlLcXrWX7/jqG9erCom07+WBlhZ1dT7ELx/75xosYP6A3YV3POiVVUWiJtrpSbRPDC3t63ltB1cd1fdrnAzni+JI46w4HjrQg3okdXeKiB5CeD9Bts1PYxtsioNUyAqOPC/D5B73aPLnaNQsVqxU0G7UY0vsh2RnaypZQky2oJSyoWcT03RWEzcQNZ5iCiKEBkmV127HigSWJNq6S9ODi93lv8tfi+99Yv5aoG/rqUq58IC0Zz7/rlToyBXpC2MYLiKq2cFZSpwG4fOIkOoSrEarSNoG4fVzzR3LnI/icqaqC5VT2EEBurp9fffdivv3r17GSog293uoy+WWThPLuJZw8qi8bp1WndnC1bNfUkT4XRaBbFuf/8ilMSxLVDd5ctBbdMDF9qee5+7l3mPPDr7G1utY7jBk7q1p5aYc2f4PW8MDyV9Ct1PkKAX3yyriiV/qi87+AoytQo11wCoSGpbR5NcK2gwalbItBcOQF8SJggBCiD7ALuAZIN469DdwEzAeuAGYdjH34cKFH7hB8ShDdSrczC1pMf4q2bGFhWAZgL0elxBHCzrI4RAoDAAAgAElEQVRZgD8QIxz243qI4lcmobKplr2hJspy7SVqSNcTaScdO65UHEVVtTVQJZZFQ3b6eGqxbn897Vhrv7LlnDvdseWO3xq/9xChCME3bpzA5eePZNPWfUgk8xZt4sf/Ny1FCIO3aSJe9y4Nu2oaefjZD+N5mZOFtqYpBPw+olgpoc+qIuhYlMc/Zn2eQgnUDdtNqRhgJcVPCGDGygr+tnBhImAkeaICfnTORDTl4C3su0J1LK2tRHd4dnGih4StzXVtv6y/IIgjQ6b5/xkfYZdFana+5wIzgDaLBB5Rf4uU0gDuAj4A1gH/kVKuEUL8XAjhJmd4CigVQmzCTqr8wJGcU1volz+aEl83VJEcnWR7sKpjmba3XF8YzdEiTSvzAVAVSV5uFL/fLkGf0BQECIGRREqd1KcvgSRqU1xZcz+oic8S0sazBbbla0W+tvf5lDIReZeybHdOdoS4w+4Z+pV3YuGKSn78+7epqW/h8Rfm8q83F9HYHCEl41typzYMXlIIoqaZUQJJADl+jWvOGslrv/wq9101kYKcALkBH35N5YR+3bnvmjMIxVKT/cdPkXbumGmyu6GRfU0tieNJf4OqypCyTu3/QTywM1SbVB1GIJ0NBCEzmpIa878KeQDb0YGglNIVwjif22WwP+I8YinldGB62r4Hkz5HgCuP9DwAopE5tDT9DdPcic8/hvyCb6L5UulHilC5oc/DzNn3HKvqZ2NKnT55J1ATK8ZsXkX6XZOvWhT+P/bOO86K8nz732dmTtvO7rLsUpald5COItiiomLHEnsvUWNiYoqmG2MsKcZoYhJjorFgBRVFQBQQpAoC0suyy7KwvZ82M8/7x5x+5mwB/L0xcPE5n2XPzDPzzOzMNffc5bozulHe1kKzYX8DCAEOzcDvixcbKvRk0jMtC4AVFWX84JP5BKWRsqsFAkyNSIsgxS5op1r+XWHzVqyEtI4jRCpSGLYp92+ZdV9VECb8fNq7v4YdpVYO97I1u+wV5aREUUPaxDHuBQnRPOHYwFuMRZoIn19naN8Clm3aS4vXz1N3X0RGmousNDf52els2Hug01amQ1EY1683cs2ayG7jUgKlwOM4stuuJD0/Zewhy5GGW+l6ifNXgv8dgu0sWoUQ46SUnwMIIcYDnZKx+9+qrGsHrc1/o7n5UQjJ+xne/fh9H5Cb/yYO55i4dV1qGmcX3cHZRXdEvittLWNtwzYCZrz/WFNVHh55PeVtzbxXsZZ3yrYmdWwWCExDRROhBqJCQVNUHpsyEyEENW2t3Dzvbbx60GqQqYjQa128C0IEQTEsf25KWhBYLYBiiFgYoJqW/kJYNF7qodchR8jAjHTwOLK7x1Y7ohOIjesE9eiToL3ptKf90BWbXQIPPvsBOEAIBadDZdKwYh6/43wARvTpkUoLKO4h4HZoTOjfm5MGFnNCryLWlR+IK2UXQO9u2fTpZl+KvK22mr2N9QzIyWVwbny5c5W3hfLWBvpm5NDDk830giEsq9oel0fsVh3cPujUTmcUxeKINCVs8L+kM9wFfAd4XQgRjoMV0cmaiGOCiE2zmeam3xKfX2wgZRtNjT8hr/u78etLg32t66j27SbLUcjAzKmUpBdzXd+r+HfpS2iKCtLyEd/W/yYKPYUUegqZmDeIgRnL+fP2j/CFrGOnouJWnTwx6So+KNvO9sZqhuUUcMOQiRRnWAGbt3ZswQy7KARIVSIS3BzCCJFwaJ12eUbEpNYalgVtCjBj1OOEapFxOJsCTUZ+T+nbi3omItMII6doKA2VhymDWdg5AabwFMJwqEqkwCISVBSxa3acbRKXymaCVCS+gM6qLfuYvXg9V585Hoem8tPLzuDnry4koBuYUqKpCpqiMGZgT76srCLN6eDKKWO4fvo4AB69cAZXPP8qrYEAbYEgaQ7L1fGnS89LmkOj38eNH7zF1toq1NDDenT3Qv5x9sU4VIXvrXyHjw/swqVq+A2ds3sP4aEJF/KHbR8yr+ILBAJNUbl94Klc0bdrgbpzzz33q1NgO8ayJqSUa4QQQ4EhWBffNillp/xE4v9jXOywMWGMW3YlayJQezMNvqUYUfdNDAQ9epZhFQGCV29k9r77aNFr0E0/mnChKg4u7/s78lx98Ro+tjRuRQjBiKxhuNRk/dh1taX8Z+8KqnxNTM4fwFUlU8h3p84Z/dnSRbyweX30CykQQRGXJaH5RXwXKBOUxOAbRIN2uvVTNbAnocTijtA4EXI+i6AV+LPOENE29JJobkHk99DPOFZL+M7sXFPQ9hAhWyAs+BMO3kmFpGKMiN5yaMbtCclHlsXIV/YpyGHOr28ELMW2X8xeyIcbtmOYktwMDw9eejpnnjA45Xz9us6HW3eys6qWkrxunDN8MGlOB1JKNh46RE1rKyN79ODHyxawbH8pwZgHpVNROb1vf9wZkgX7dyRYvhoX9B3BI5POw2sEaAp4yXVl4FCOTul0LIQQ66SUE7o6zt27j+x9z32dXn/3j+47rP38N0EIkYYV5+orpbxVCDEIGCKlfK+jsceERawEltNNQL0UNiW5DmLfbxcdfJLGQCVmqMw4KL0EDR/vlP+cGwY8j0d1Mz43WfA9FuPzShifV9KpuQVNg9KWemsaMaQlkahSpacnk5Lsbuw+UEd1c0znkVAZb1zvuch4yz2qaQqmYSOX1k7Gg7U9gXRIzBAZS2JIOC6CF50Ddt2XEwJVR4KoxRvdSywJR1MHov9PfEUX4Thf4kRFws8QGlq8VldpIbj7H3P4ovSAVaAhrI7ND77yIT3zshjRpzBu3LJdpby0ZgMNbT5OH9KfW6dOIMttiUWVNzZyw1tvcai1BUUIAoZOwGUkubMCpsHifXtQMgMEiXf4+wyduaWb+cnYM0l3OPF4ut7o4P8Cx6Br4nlgHXBi6Pf9wOtAh0T8PyUMnwoCAwGkJ3XmcOD2XBC5YXUzwJ7mlRESjkLSqtdR6y896nN7cNlCVh/cH55oOEEDVEtg55XLr+CFWbO4ZOTwJLEY0xGyBIn3pSoOGNu/J2mpGkeGiSrBgg1X7InwSpq1fUVJ4sC47ST9P9ZSjl0uBDL8sZ9ZlxDVhojZRXj/EHdSIlwb+1YRk4GSeIASaPUHuPShF1i2ZQ+byiojokth+II6T72/Iu67JxYu49uvvcsnO/ayYX8lTy9Zyfl/eZGy+gYeXvwJZ/z9n+yrqcfrC9LiD+A3jWRJ1BAUIdCEvZWrCoU6f4fpqbYwpM72phV8Wv0ymxs/JmgepWahiTj2siYGSCkfA4IA0uo31akXwWPCIgbrHnPiCL1/tiFEOorai6ycX0XWMaWOXVWdNV4hYB7ehZ8Kdb425u6OKeKI7AxUTfDGRVfSK9PKqrhxynje3rSFeq834hcVISISCRXKpoSNlYfA10HpW6wFbdjxqgAVRvYrYueeKvwB+0h9mMQcIVeBocuoZRpxbySQrxCEC2M6vFKFCG0qut1kn3D8dFLd2yJ0vFJEXZiJ0pghnTZ0JGVV9Tz80uIksgzvf2VpOXf9ey4zTxjK0F7deXH1+jjC9usGtS2tXPziy7QGA9HtSEKdplPDoSoYwrRfSUCBJ1kfuyO0BOt4ofQ+vEYzAdOHU7j5SPkb15Q8Tp6rc5rXncKxGawLCCE8hC8PIQZA51piHxMWcRiKkktWzq/IyPw+2bl/Ib/gIxQlGsF2qml0c9q3MpfSpMA98KjOZ19TQ6TteSI0RaF7evRGy03z8MI1sxjbqydpTgfdM9K595QTUe38xFhp/qqm2N/o4SyJjqyREOFtKT/UKanLJ35wMU89cBlOTUmaU2Q3gngCTYinJU3pMDIAOoNIo9CwRR1+rQgRZVgs3jAldc1tKDGBJ4mlS2FqEJQmn2zdw0/fXMjdL7wT1+A0jAAmTX5fpFsHxFrowrKfEv4OHk3jexNO5rrBEyIdwSPLVAe3Dp2CS+26HfXegd/TFKwlYHoBSUB6aTOaeKv8113eVoc49izinwPzgT5CiJewCjx+0JmBx4xFDICSgyftynYV2E4v/DZzyn8SKnO2rhBNuJhWcCuaEg3MSSnZ0bKX1bUb0ITG1PzxFKf36tJ0emVkpcwHVYVCliu6v+1VNXzzpdkEDROfoaMHTf62ai2aosTd4BHEZE7EukXDlpzShYs/oJs4FKyofaxVnLCNx/+9mLzsdEqK89m5J17LOTyn+N8tB7OM+X/S8rjhh+/SCFu5kfs+XBwTMy0zHLBL2K9TU+M1jMMkHrOaNxCkrKbBGp9wVwkz1AM24fgjQU5dUJSRgXAKDrY20zMji+9OOIlLBo/AlBKP6uCf21fhNw3cqsYdw07k9mEn0lV49RZ2tWzCkKAKgSqiV0hD8BB1/gpyXV27htvF/w7BdgpSyoVCiM+BKVh/3nullDUdDAO+pkS8bqP/sHQkMCvBNx8856ZcpU/6GK4o+QMrq/9DlW8XWc4eTMr7JiUZ0YCulJKndj7P6rov8JsBFBTeq1zEBT3P5Iri89udQq2vldf3bGR7YxXDc3owtVcxyyvK4twTHk3j+hFj46Lg33/3A5pjhGL8uoEfgyy3A+En4q4IIy89jT55mWwoPYBuJDhcpEU44XS1zsCZ5mDq0BIWr9phf4NJKDvYQHllfcQPG4nrtWt1i+g64YwFGf/wiNlFHBRVJJU8h6EqVhfq6JGLSBaFtGk9KAHFoaBHBOejywJBnWfvnsX9L8yj2RfAh4FpU/USmUsiESNQTGmpuyUejwCP5uDR02cwrW/fpG0qQnDvqGncNWIqLUE/mQ4X6mGUR1f5Kvj7np/TYkQnpwmDNCWAEKAIhUBSWf+R4VhzTQghpgIbpJTzhBDXAA8IIZ6UUu7raOzXkoi7gnPOiKkwlF6k901EO0QMUOAeyAV9fpFy+eq6DRESBiufOGCavHNgIRNzx9A/wz61bnPdQa5e/B90aVm1C/Zvx6GoTOrZm9UHKnAoKkHT5LLBo/j+hGmRcVUtLeyqq0OGUxhi0tq8qkHfbtlUNbXgD+q4HBoOReEHZ08nw+XkjRUbWbx5d6S7RCRFLRzoCukhJCYdxN5DAotkxg3rTU1tCxt3Juo2xUBar/3hbYTJOC67ww42C5Ms+Rg4nSqnTRrEks93oetmpFAFYPKYEu67/jSueODfmHqUWBODe4m7NwMmqjumWi8EU4H/LP2c+lYr9iLblaWz2bYATVEJkOy26JWTxa+/8Q1bEo6FpijkuDxx3+1tqWZZ1TY0oXBa4QiKUvSsM6XJc3sfollvIHbiulTxmxpuVUeg0N3d/hyOo0P8BRgjhBgD3A/8E6v70CkdDfxaEvH48eNZu3ZtyuVm48/A+6r9ws7lV7eLDw8uiZBwLIKmzrLq1REiXnpoO09uW8C+llpynek0tjpo0aPjfIaOz9Cpo5kV37yDytZmirNyyHJGXRKGafLTRR8RCEfTzDDJWeI/QcPk2mljKc7MZmtlFQLBa6s38uM3PrSsQlNyz8yp9MnOYtO+g1Q3trJk0x5Mw8RnGtYVIEFIgTRlxBqNQAF0ic8X5M9vforfG4zP15XROcW5fUOdOdvRYY+xVRMQ8yRIMqpCKweCBtv2HuL7N53BX2cvp76pjW5ZadxxxcmcN30Em3dX4nY6aE38O7VjpQkZtVJjoRsmi9fvRldD/mOTsM5T/PiwtZ0Ah6rynVNP4nfLV6BGMnRMvn3SFO6Y0nWlNCklf9j2AW+UrcIMpQ0+tWMBdw8+01YCs7R1Gz7DPoc+IB1kCJUzC+9A7WI38o4nenQ39zWALqWUQogLgT9JKZ8TQlzfmYFfSyLuCMJ9NtI7l6Qyb+FBeNp3HXSEJdUfs7VpK3ZxTonEF0oFWnTgSx7c8GZEgKXS20ybz4UdK+1pqsXEZGR+civ1VzZuZPm+fRFyEmHZyhj84sPFzL/teiaU9Ob0x/4elb8M4XcLPkWTgty0NH4wczoPzDqdB1+cz/KtpRghiU1TSss1msJaBGj1BqwUt8T1QspwcVZ14jp6agvXlqvtUuNCRBnOciitquehZz+MrFbd2Mrj//oIrz/IKRMGEkzIRhEQ6U2XuAuJZfmmMnRNQ1p+5fDKBtHfgTSng8FF+WyurYpzM7k1jdOG9OemSROYNXokn+zZi26aTCspoXtGeoq9tY/PanbxVvnq+DZJEp7esYhJ+QMZlBmf19xqNJHqyCSCK4p/RXH6KNvlh41jM2uiWQjxY+AaYHqoVVynhD/+N7MmnCeB62SsHnYhCA9og8DTmfZS9tjTsofZ5a+gCR27x71LcTE5dyxSSp7Y+kGnVbAE8SpssXhx/Qa8IaF4OyEfQjN55KMlLPxyJwGbqD2ALiXVza389I2FfLpjH6t2lEXcFe1Voip2WQt2JKnYLIudY7gAhZgzl5Q21g7CFrJKUqAsFr6Azl9e+5ScTA8Thxfj0OIds5oiKOmRY1mvxM/HoaqoSjsnIwSB9bfQDMHMMUO5YOwwfn/1ebx4+xX86Yrz6R/SGs50Obl+ylgeu3gGAFluNxcMH8YlI0ccNgkDvFm2Cq+NwJRu6ry7P7kLdx/PQAxpHxTu7Rl49Ek4jKOcNSGEmCGE2C6E2CWESFJpFEK4hBCzQ8tXCSFKYpb9OPT9diHE2THflwohNgkhNgghUr9mdw5XYKWr3SylPIjVfejxzgz837SIhYCcp8A3H+l9A2QQ4bkQPBcgkoo6OobfaGNn8yrmVX5M0AziVCUBUwuFa6wbVxUKw7IGMDpnKF4jQJWvOWFOEiEk0ob1itIyKfTYl0A3+WPSEGWyNRzG5oNVTCjohS/YTq4vVhHCHz5YhkNV8Yfaz6ciNbdTA0MSCB9pO6pwoenZZz+E10nFcTG+6tihYf+yqgp0U3ZI9pYjWiClpPxgPQ/deS4PPjOPdVvLcWoafj2IM83JwcZWZKInXAhcqorpEASNZLeTXefnNIeDR66YgRJD3qcM6scpg/phSmn/EDsKaNbtg2oGkuZgsthXjjOfsTnT2dDwaaQFGIBDODmv53VfyRyBo+qaOJJGxEKI4Vha6COAnsAiIcRgKSM9Zk7rbHZDB8iVUv4+/IuUskwIUdaZgf+TRAxYKWqeczsMzHWE3c3reLP8NwihsN/rQqIhBGQ4/PgNlaBUEcCwzGJ+NOxbKELBqWhoQsGIsXKFAJcriM/nRBUKhpQ4hIJDVXlsyvkpFbNO7tuXOVu3YkppWa5SJpOxBI+qUedrw+FQkwsvEqyOqqZW0mJFF4SVE6uEsig8TgemNJk2qj+NDW2s3Wa1HYxrtdQOpAokt8Gzd0GE5maqyQvDuzJFglugA+iGSVa6mwyPiye/dwmHapuprG3imbkr+GL3gWhgL+acDy0u4Oc3nEWTz8+3/zoHU0r8AR2Py4GiCNrQ4zJTPE6NG06bEEfCsfiqSBhgQrf+fFFXTjBk5Ub6KqpOphXYCyhd3Pt2Cty9+bTmPdr0Znp6+nNO0TWUpHdecKkrEBx118RhNyIOff+qlNIP7A1pn0/CakZxNPGaEOIFLCvYDTwGTCBa8pwS/7NEfDTgNVp4s/w3lhUhwaWAz1StMJkAt2bgxsCluDij8GTUUDmqpqhc0Hss7+xfH+fHczlgUFY2Y7MHsa2hmuHdenDD4In0ybCPdgNcNWY0b28JXWsqoe7KMWQc8htX1DXxr7r1oFglziQWesRYs/mZ6bQ0eKMCOKEbRnELxvfvzcwJwxjdv4iSwlw27jrAt373Br6AnpqIY90GAFIgwhkeELWSzXgyDvuSE8V6rDEpTkgH/KYqghEDivAFdX749Dt8tnkfmqpw+vhBbIwl4Rg4NJWHbplBWyDI4F75zH/oFhZ8voO65jZG9ytiZN9CfvLqApZt3YtDVdFNkyumjuHWMya1P5kUkFLy8pcbeXb9Guq8XkYV9OAHU6YxtrCo3XGmNPnt5nm8Xb6OoGkiQxFRVZG4VY3+GQVMT0HEilCY1v18pnU/shhJl3B0ifhIGhH3AlYmjA0nTEtgQagP5rOh3piHi8lYVvgKIBN4CZjamYHHibgdbGv8NO73LM1Hk+4JXV8hlwQqmVomk3Ljr4nvjziHCm8962pL0RQFKaGHJ5tnJ19HD09Wp+fwwsYNluZD+CVKA6GHyFgKW7+xqVot5wi7smOsU5emIv0GQRkvBiQ06JvXjSdumYlT01i6aTertpcxdmAv7r1sOo++vNiynIlRbAuPDf2UWEJD/YpymTS0mNc+XB8t6RXCqiJJqNiNeGqO0IBUhMDldlCQm8l3rzuV6x96mZY2f2T/81ZssWRABXGWsASCiskVv/0PmqpimCaXnDSS+2edGpev+8cbz6eupY3qplZ652aT7j58oZ1fLFvMa1s3R3z/n1WUc9Xc13jh/EuZ2DN1mfErpauYu389gbjO4AIhVW4dcBpX9ZtqSbT+N6Drwbr8BB/t3xJI0e4KSdxDqnXaGztVSnlACFEALBRCbJNSLu30rOMRxMoQ8GBZxHvD/es6wteTiGVzx+scBXiNlrgghyokPV0N1AXT8ZounIqL8d0mclnvy3Eq8TemW3Xwl8nXs6e5iu1NB+mZlsPonD5dFu1euGe3ZcyG7i+JlSLlMAV5iofaFvsGAO40J2/ffBU/nv0h2w5U41CtCrypA/qyantZvGUoQNNULjl5NHsO1nHP029jSolhmggEQ/t0R1VDovKqwAxZu2EvqwsFISBgmBjSpPRgHfuq6i13Q6yXRAjrOEK+3AgOQ4o1NvNBAr2LuvGjm77B2KG9+dNrS/H6AnH6EFF3RHS8wHLJICSGISOuhzeWbyLD4+Lu8+ONmdyMNHIzjqxVfVVrC69s2ZTUWNSr6zy0fAnvXHZ1yrEv7F4e0bmOhVPVGJFTjEs98s4cpgxQ0/RX6lpfxDBbOx7QHrr2Z63pQAbzSBoRpxwrpQz/rBJCvI3lsjhcIl4DzAUmYlnizwohZkkpZ3U08OtJxHo5ZuvzKOk3fqW76Zs+ClVomDF94x2KSaGrjTE5J3Fer3s63Eb/zAL6ZxbYLtvdVMNftnzGptpKSjK7cfvwExmXH28R2QbnFHC5HQRbzZSPe28wSN/8brx815Xsr2ukrqWNAT3y+MXshXht+q8FdYOlW/bwt3c/o8UXH6zaWl5tBcvC5Bmqhgvve+b0kbzzyWbA4tSgYVrpXcIqlgtbRpKwGyJ0VF2ri0hCZHuAISXjhln32uqtZUmVhrGDwrm+JtjmDemGyQsfrePO8048rCq29rD+UCVORbXt8Ly5+lC7Y+sDKYhRQrXvyI0TKSX7am6i1bcSyVGosju6ronDbkQshHgHeFkI8XusYN0gYHWo67IipWwO/f8s4FccPm6WUoat+oPAhUKIazsz8GuavmZC8x+QXXhiS7MOs/lJzJpLMOtuRfqXxS0PGLXsqv0Vq8pPZs3+0ylreIZCV1+K00eixWRaCAROxc3J3TvVASUl1lXv54L5zzO3dDM7m2pYVLGTaxe/zNzSzXHrzRg40Lbjr26a9MrOTrn9/PQ0NlYcJGAY9M7NZnRxEekuJ7kZHttAkhBgGGZcF48w/EE9pfaOw6HyxfYKDDu9C0KdQUI/I1VtIRH3sIRnV4R9bNPfVMHw/tHc2e459qpkkWKN2E8KBHQjrmvz0UKu20Mqhb8MR/vujsFZhbbfG9JkeI69WFVX4A1soNW/6uiQMETaJXXm0xGOpBGxlPJL4DWswN584K5QxkQP4FMhxBfAamCelHL+4R5vDAnHfvdiZ8Z+PS1isJya+pfg7DhgIo2DyNqLwWwGLGtPBlcj025CybyXoNHA+gPnEzTqkKF36fKGZ6jzfsKsPv9hTe07rKv/gKDppX/GOKYXXEO2M97KDZgBDvlqyHZkkuVI3Y0jjAfXfBCXCyqBNl3nJ2vmc1rRQLJclpD4D0+ezorychp8Xry6jioEDlXlkTPOxC01vvvWPPTE7hcSGtp83PDimwgBPz/ndC4YPQyAS6eM4u1VXyalubk0jRNKerJ1t71VpjoUhBnfTw4sLqttbOeBqMSkfsVawCGfQjgAmGjZt3dvSgi5akRk0LUzJ0aWf/PMcazdWoZPNyIWczj1zq7yLRXSXUdfcH18US+yXC7agsG4Y3SrGleNGN3u2HuHnsVdq1/EH5Of7lI0pnQfQL+MI+sMDVgknCLfuMuQpG5Ce7ibPIJGxFLKh4GHE77bA4yxW///Gl9fIsYE0Tk9VtnyJJgNxHXUlF5o/Tsy7QoONL1G0GiIkLC1dR+tgW00+T7jxO6zOLG7vZtHSslbFe/x7oEPESgYUmdMzkjuHHAjLtXF2rqdVPkaGJLZm8FZVqC2KeBjT1Nt/NEYgClo1nXGv/4nzu07lJ+MP4O5O7fiTrcaj/bUMji1Vz9uGDuOgbl5SCm5dtIJvLB6Q1RwJvQjYBiR198H313I6r37Gd2rBzNGDOZ7F0zn8blLQq/dEsOU3Hn2FM4YOYiXFq1LOkYBTBreh5amADsravD6gzhUFUWBB675Bk/NbsellpiSlkjGJFe8RdYNF4GEukdHEosTXBqqolCUF334jRnUi6ycNLz1LZGdSjXqFondfcSNnDDPHjkZKVPTUmH53n38aeln7KtvoCS3G/dMm8LUfn3j1lGE4N8zL+Wqua/j03UMabmXJvfszXcnn9Tu9ifm9+NPE6/miS0fsLP5EOmai8uKJ3L30DO6NM9UUJVuCOGgk23WOsQxWFl32PhKetYJIR4HzscyP3cDN0opG2zWKwWasRhS72zPqglj3HL1wrGgDgSzBpyTERm3IlR7CT/z0CRI3j3ghMwH+KLxNVoCm22WQ8/MGxiQ95OUc5l/cDGvlr0Vpz2hCY3enhK2NQZo1a3IvUTS25PP5cWnckJOCae9+2ykmk6aII34d2WHUHEEHQR0M07mUgGeP+dSTunbL/Ldl5WHuHX2HBravJYou7jtJwUAACAASURBVO1JgHRVQwjBs9dcRL+8XJZu2YMpJdOH96N7VgY1Ta3c9IfZlFc1RoYJYeUVv/D9KykpzGXF5lJWfrmPuhYvew/WUtfiRZFQW22nZZCAcAJFwhRVGTKeYlhRhg424k6I/ZmwnbzsNN5/8vZIIPSf76/mH/NWRgtWYoclVOVF/dbx3197xji+d/EpHR9TCHM3b+Wn7y/Cp8f0ltM0fn3uN7hg5LCk9XXTZFlZKYfaWhhTUMSw/K5ZtOEWTkcThtnMtgPjMWW0AcLo4orD6iXnKewjB1zb+Z51Xz7x9e9ZdyT4qnzEC4GRUsrRwA7gx+2se5qU8oSu/REUMFsguAqM3eB9DVlzPlLfbb+6sI8mS+lHb/opxaICu5dhgQOHmjrHF2BOxftJAkBBU+ez6ipq/E20GX58ZgC/GWR3SyWPbHmdWZ/+kd6ZGREBmEQSBggGTdoCwSStYVPCLfPnUOeN3ixPfPwpDT4vutHOQ1WAN6jTFghy18vvkJXm4uLJI7l0yigyPW5mr/iCc37zT0obGzGU6Nlwuxw8d9/lDOiZj6ooTBvdn4LcDJZs2s2OihpqGlupbmrFcHYiNpPAG4oQfGPi4JDFSygIKOJJ0S69LZz5IKw2TnfOOjmOlN5Z8WUSCUcQGzgEnKpiZeOK6HemArM/28jGfZUdHRFgkerDCz+JI2EAn67z8MIltv5zTVE4raQ/Vw4fHUfCZc31fFi+nU21lbRnJB1tEgZQlUz65j+PItJRRAZWs4nDx9H0Ef+v4ytxTUgpF8T8uhIrgnk090B8BxIdZCuy6TFE7rPJq3suhtZ/EfYPx0KXBkIeZIAG1aZCs6kR9rgKoVKQnlqbwpQmjcGmpO+DpoohbUTMBUipEzABpYYsZxYBw6Q5GPsqGBqlp9ZrNKTJO7u2ccOocdS3eVlTXhHKakh49Y/dZMxkgobBUx+twClUFm3axb5D9UhTRhpj4oRwz1FTg10Ha8lJ9/DKkvVsKj3IF7sPYAZlvIEqBM50Fd1rWK4Au5sr5jshBDmZHr579akcqG5k6952MgZsTkPEinUo1LXGt7Bqr5uIhLhOzsKhIFSQenw6n1/X+dfH6/j9DTNTzyuE8vrGlBofPj1IRWMTxd1SP9CllAQMg3tXzOWTA3twKJYUZ3FGDv8+/Qp6pHUcczhayHBPZVjPDTT7PsIwm4DU6XQd4jjBdhr/Fz7im4DZKZZ1uqpFCHEbcBtAcW87C1dCYIXN9yDS70T6P0XqOxEEI5aGX+o0yBA5C8hTDLopOgeMbAwEA3N/idvRx3abYFUr5TiyaQg2xn1vtqeiE0KAICMKPVzaczo/W7mAxoAvMg9r49K+rYMEE8mhVssV0BIIWL5MI7qqXUpbrE6EN6Dz3MdrCVflJQXRwHILmNAWCPL+uq385tWPCOpGNC1MwyoUibnZAobJ0qfvos0X5Nz7nk0mY0GkoEMi+e7Vp9C9WwY/vP4M7njkdYJBPSJE5Haq9C7sxs6K9iUAdMPkH++uZHCf7pw00nLXfGPCYF75aL1t26JEUXifriN14jp2gPVA219j586Kh1/XKa2rT1J6C8MwJRlO+6DfobZmfr5yEYvKd2FIEyHAVE38oXnsaqrhlk/e4N1zj26aZsBoZV/Lx/jNRgrco+nuHhlnYSuKh+y08APoMIk44eF/HO3jsF0TQohFQojNNp8LY9Z5ECul/6UUm5kqpRwHnAPcJYSYnmp/Usq/SSknSCkndM9N1Z3Y/oIXSjoi7w1wjMeQJiYmQanTKOP7+ikCVAHF7l5M7L2UHpmXtnMGLMzqfT6uhGKONC1F/i/ha9NaVudvoU9mFhcOHIoWIoLw2zmO1FexW1MZX2j5w3tmZZLmCD2YBPGFH4TcrokGohn6PvRp77GhKQpf7j1Emz8Yn5srLMsybpYC1u+q4I4/voGZuCwMNTROgdmLNwAwrH8hL/zqas6YPJi83HR698xBOhX21TbQTleryMR9AZ3/fBgNMt4wYyL52em4HNHrJM4XbIeEc6QqglF97dPFwnhzw2am/P6vfPvN96xzk+j7FoKinEzuXTCPuz94lxXlUf2X1mCAC959gYXlO9FDATtTStBF5AFmSMnuphp2NR4NPRoLB9s+5/W9F7C6+g98XvMsCyvuZWHFvRg2+tpHgsQswY4+xzoO2yKWUn6jveUhQeSZwBkyhbPr6Fa1OMF9UTvz0RCeCzEDVtmyjmlLFAIJ+jYcSm6n9np6wTS8ho+3Kt7DlFZl2aTcsZyYW8ic/SvjpDCtYocwUwqqWgxu+fQlQKK6gwhToPstRhaqRDpMCMZHrBQBfbO6cVqxZf2pisJPzjyVB+YttHyUAtBAC4k46KYZydcVhvVRbAR5Up83aPL54lLQ7MhbYnXxuOepOYQnKkIlzbHWdvicSwEVNdE3iS9LD/HRxl2YUhJsiU+Hi71Zpd2XQFV9tKAhO93Nqz+7hreWbWLJht34Ajp7D9Xhk7qt5KcIbThWxN6lWaI+qbB6335+Of/jOL+wDCd3CIuEUaAi2Mju8joAPt67hxvGjOP+qdOYs/tLmoJ+yx0UN5NQ5DJ0mWiKyiFvCwOz81POpbPQTT+LK3+ILqPVmLrUqfJtYlP9C5yQd8sR7yMOxy3iTuMrcU0IIWYAPwROkVLa9qA/oqoWrRiEK3Tn+ECkgVqMyPxu+/PyzEQ0/hJJy1G7RoQQzOx5FjMKT6cu0ECGlk6a5kFKSYErm1fLllLtb8aUgoAhMEOM5g9YaULhG1EIUBSJ6jAwgtafRbhMFAf00fIob27EpWhcOmQEP5gyLa7ia+aIoXRL8/DUspXsra2je0Y6pTUNSdVbYS1fwwStA1dGeE79undjZ2VtUrAsLFURex4T270ligolIivDypXeXVHDL56fH23nFBuIEpYbQ2K9rahCRPzhYaiKYPyQeBdShsfFdWdN4LqzLDIN6gZ3Pv0Wa3ftT5qHJCZOqAiG9irgwVmns7umlt8t+JR0l5NZE0Yytm+0aOLZFWuSgnPhfGgJGA4T3CIu2OrVdf65YR2XjRjJ6kP78ep2aWLhp5V1LgKGzrAc+8rMrqKibSV2zntD+tnROPeoE/HxIFzn8VX5iP8MuLBENABWSinvEEL0BP4hpTwXq6rl7dByDXi501UtIgPRfSF430OaNQjHCeCajhDtC54I4ULr/iF67eU4jOQb0oKCyzW9y1FpTdEocFtWiyFNntn1Kh8fWoNDdVDg0XEraVS2OvEaBsMye7O2qoqAjCdKIUDVJEYwSo1up8pHl9/UYant1H59IzmrP//gI3ZV1UW3G7cTwAWmzxLvkaplJceScfhelQKLhBPHSyynlhE7yG5fAqlZwSjM0P5iVgjrZPzx9aUYYTa0g2JFISXQtyiXsqqGiP9XAG6ng0kjirnr6bfZdaCG4u453DJjMpOHFhM0DBZ9sYtFG3bgcmnJD4/wTwHXnzqOb50zFYemcOmfX2LHoahLYO76LcyaMIJfXHQmAGX17fiPJZhOGad1Ebu/hXt2Wz5hKUKPmPCDJX52HtXB5QNGk+s+Mn2LMIJmS8qqPl0e3cahwHGLuAv4qrImBqb4/gBwbuj/R1TVIpRukH5tl/1LilaEs8cyTL2SrJYXaGr9K5Yb2wDcCOEmO+fhDrbSPmaXzWdJ1TqCUidoWFaTYTZzQl4ffj/2+3xeW8ZtNa8kqGglw61qXD1obJf1DiobmyMkkNIl6gDhD1mBGqE65BgviLACfLbWcpgvzATuTHHjyZC1GXZvhH+2+YOUHapn457OpYl5PE40t8bAPvmUHqgjqBtMHFrM9HH9+ckLH0aqBasaWthcepD7LzuVOau/ZMeBGryBoHVYSsxxhqGAx+Vg6rB+uJ0aj85bEkfCYPlvX1+zmYvHj2RMnyJGFfWgvL7RnmwVrNaINiELv6Hzmw0fo6mxWTXCekoJq22VUAV57jRuGTaZW4d1vaddKhR6xiFtGpiCoNAz7qjtJ4LjRNxpfE21Jo4cilZEetZd5KVfjlt4cAgX6Y6RFBS8g6aVHPZ2pZTMrfg4KbfYwKSs7QBlrZUMyiogmIKEBZDhcOFSVGb0GcL9Y0/t8hwml/TGpbXzdiAABUoKcjj3hCHcfsZkbjx1ApqmxPleu3wfpXwqClAEUrU+YT+AQ1OSBIZsESK7lkCAreVV7DpUS1qmi38+cCVnnjiEp+d9hjeoRwOUWDnTj77xMdsrqiMiR+G4pVRAhFsuKVYnklF9C5k0yHJvvL52k/00gH99agUF75g6CWfCOY6cLwUUQ8Fp8wCVLhOJJBhxWYROuGFVOTpckgF5mQzKy6ZHelpKC/ZwkOEoYmDWTDThjvlWwaGkMT7/zqO2H8Ay8rvwOdbxNS5xPnxIsxmz6VGk7zVUTLIUABXMHci6G5H57yOUw8vdNKSJ17B/zVOFSk2ggeL0Im4YNIUXdsX3HnOrGvcNP4P+GQX0ycimhycTx2Hoy152wkieXb4mdVEDMH1QCX+/6uLI7x9+sQOnpiZlRtgixHZSIdJMNK5bs4xftT38e9FaWvwBkqQxYyFCLo1QybEvaOBvaeWaJ17F5VDxBvS4QGB4K37TiM8AtEmny053c+uZk7jy5BMi7qiU7aaw3jZ+OX8xWw5WMb5PT5bvLYsrk5ah7Be3Q6MoK4MDrc0hXYnQSg5SnldFM5GqZF9rHfta6/iy/iDz92/lLyddftQKOCZ3/x7d3SP4sv5V/GYjhZ5xjMm9iSxnah3kw8Zxgu00jjkiltJA1n0T9N0k53XpYNZjtr2KmnHrYW1fU1TyXd2o9tcnLQuaOn3TrC4M3xl+Gj092Ty7/VNq/C0UZ+RyeclYBmZ25w+bP2FjXSUCmJDfh4cnnkffjM5lcYDVpPKlay9j5rMvpgzEFWZncLCphcIsS6/j1OH9cagqlrZ1CEq0hRIx21EUq7+bYUrOHTeEbI+beau3Ud/UFqlQC68rsEg0LI8dm0GRlenm4w27rO7JVo1zUtpf38IcKuqb4/N0RSjFGmmRcMy+IsvDX9gdfDiopoLX0JkwsE9ck9H8jDSqmu2FjDbXVLGx/hC6KaOVkeEc5Jh9GabkPxdfxurK/dyz4L3oeu1AIBAx5qHXCLKyai+rqvcxpaCk/cGdhBCCAVnnMCDrnKOyvXb3dZyIO41jzzXh/wSM/UhSCZv4kP6PAZAySKt/PW2BzXRSaB+A60suwKXEF504FQcndx9LnitaYTUyt4Cfjj2DqweOpdJXy1NbF3PdkpdZX1uBIU10abK6uoxZi56nKdC1YIopIDc3DVOVxP+zSOjtTVuY8dd/saHC8s+6HBpP33QRHo+G6cT6qFa5r+Gw/m+oUNwzh4evmcFPrvgG7/30Rn55zdncd+kpvPvLGxk5sBDpBOkC0wXZOW6UcAFF2D8c+rjdGvWtPssCFyA1y10RqQPQwJmpUeVtQ1GiecBmWM2tIwPRpgde2LI2NesjseQu563fFrfaD887xd44VyGAaWVtQCTjJbFjiUNROLFvHwoyM5g5eCiZ6S6kI3QOIgeYDEVLvsbajCALKrbZrP01gOzC5xjHsWcRBzeAfUZdCAKh5FHfOo+yuh8iQ1EsVcmiX/5fyHCN73AfpxRMQAL/3juXukAjTtXBGQWTuLmfVSBS6a3n3rX/pNrfhCFN/IYOQqHR5yRRlcZE4jWCvLn3C24c0rnAzY6aGi556WUrvcqJlZEQCsapoXs9YJgEDJP75rzPR9+6CSnhNx98QjCU+wtEfKgySORKKa1r5MlFy3n921eT5Yn6GtfvPcD2gzVxWREtwSCmJpABaRFbjEWYl51OdYNldYYTJszwsyu0DW9Aj7g9ZFh7OIxEP4QkpQfCFqGVDSkJJLgizhk1hIY2H4/OWxJJARSK9XCx3ZQAt6qialarpV7ZmfzirNMjy68fOZa/f7EWn6GDIUCTCVFQidAMW/JXEHiOQueN/x84bhF3HsecRSyUAsCdsvIN4SbgPInSuu9iyCZM2YIp2wgaB9lVdQ1BIz6dqzlYzZrat1hR/QqV3h2AFbDLdToYnZNLrlMgaOPjqqXc+fkDrKpZz3fXPc/+tlq8RoCAaZGNppqhGSXPy2fofFFX0elj/N2y5fE5rmES1EAm3B01LW2U1Tfy2e4ydlfVxmsmhKcSQ6CmlFQ1tfKvpfFymb9/Z2mSbzVoGOhITCcYWpQg3Q6NC6cMR8e0LNOwhWrjSojIY4av1FifR/ijWHOMCM13hNhtKHD6qOQkn0FFeZhuMJxguCDoxDbfACzxokfOO4vuOWkEnTqVRjNnvvQ8jyxfgpSSb487kTNLBuBSVTI0F27pJEN1UpSWSbpDw+VQSHNptpN3qirnF4/szFH9d6Er1vBxwj72LGI8M6HliZgczlg4EOm3c9C7EimTo/lS6tS2vE5h9h0AbKz/kEUHn0EiMaXOyprZDMiYRHUwj3X1n1PnBzPEFhKTxmAzf9j5HLWBzCTvdJiMDTP5vdupqJRk5nX6ED8rK0u5LKkTc2hXn++roM2mhVKE6GImHNANXlu1iaw0N9OH9KN/QS57DtUlj42FAsIpyHN7+OFlp7FyVxnBuLI7IvoWtulyIuF3iN7ESvwygUXgqiqiRSLY3++KEJR075b0/WOLluE3jMi2w9uUIn4qEuvh9PiKZVT6W9AxCQSsa+fFjRvo7knnlnETeOob51Pe1MDmmioK0jIY16MoEoDb3lBNZWsTL+1ZxWfVpQRMAwWBU1W5bchUhub0sDuj//04TrCdxjFHxELpBjnPIhvuQkGGfL9+cJ2GkvVThFqEv+V87NoLSPz4jVIAmoJVLDr4DHoMYevSz6bGdVT4u9FmmJg4SaQV3TRIc7TSHExP2r7bGcQfTP6TqELhiv5jO3V8n+0vozWYWtg7keTy0tIo7pZNbkYaLk3Fb6ciZnNDNbR6+eP8T/nTghVcMmEEWR4XDa3t+LEFqJrCc/ddTobHxQMv29TuhEg/loy7dC+HshaECdOHlmCqsGbXfoSw9CggJrAWgqoIvEGdJz9aztqyCvp0y+a6KePYdqg6uv+EdL6wVyH8u6HCgfoWDHf8NePVdZ79fA23jLOq+/pk5dAnK1mFbUhOd8rbalhXvweHJqyYMZLL+o3m7uEp5Vf+qyE47proCo45IgYQrilQ8BkEViFkGzgnWQQdQrpzLG2BLZAQ0FNEGulOqwZla+NS2wBefVAlKHXMFD15LB0C+/QoRQFNM9F1BVUouFUHbtXBkydeTFFaVtL6H5Xt5vF1S9nTWE9hegbXDR3L40uWW/5UO8sSIs8Xh6riUBSeuHAGQgjOHTWExz5Ykry+JOmZFL6/rCahJnPWbWFoQR71ew8mWYuxcGoqpdX1uDQVTVVspSMlWG4GQgUloY20l6KciKH9evDUHRchhGBXZQ1b91fxt8Wr2VdTHzcnTVUY3beIy597BX9QJ2AYrCs7wPubd+ByqPiEkWSJy5iAmwy/LcSycgJqvW0dirgf9Dbyg3Vv4jND10XICp9TvoHTioZwcg/b+qj/fhwn4k7jmCRiACGc4Jpmu6wg61ZqW1/HjGsZo6KIdLqlWeJyAbMNg9T5popInWXhUj24FUecIBASTMOJx6Fwdt8RXNRnHOmakxHdimybfb6zeyv3L/vACgAB+5oaeHj1J0gFFMVisviiLytPVzgEmQ4XV44ZxdXjx9Az2yL4buke0tKcNDT74oeESYfUfOMNBGkM+iOZDRH3R0JqsG6Y9M7LRoCtRCUQ5/uVSii92CQhuGWP8Ny2VVQRNAycmsbAonwGFuUzYVAfrn/mNRrbvAQNE01R6JGTSUAzaPZFVfhMKfHpOkGpxPnGI67MsNVuN28b9MnO7jAH+J3yjbYVel4jyIt7Vn5tiVh8Bd1//ldxzBJxe3BpfRjc4zXK6n4csowh03UixXmPoipW3X+/jPGsrX2LYIKUZo5Dp9VUkMIk6oWOvxHvHHA5u5tbmb1vOU1BLyUZBdw1eAaDM3uR6XDj7iBKLqXk16s/jpBwGCYSnCCDEqGJuEBImMd0VeJ3GJw6pH+EhMNo9gesV/cwiYYHqcSXP9vcX4oiMGNKesOrKEFriKYIhvbqzoBCy9dd2C2T8pp4HefIZhN8vlJgRcrCxB6el00amwxlWcxeuZGAYTBlYDEjevWgKCeTD350I8u376OstoEBBbkM6dmdk373bGQ/cccVKyeauJ+Eh4IiBEN75rOjscbyK4fg1jTun3Jy8slKQI2vJWW5e42vEy2o/htxPAjXJRwn4hRIc45iaOF7GGYrAhVFccct7+UZTt/0sZS2rkcPkbEqHOQ50umZNpl19euQjgBtugNDRpnFKUz2tu3g+v5Xc+OA0zkc1Pu91Pu8KZdLRSJMEbUsIxUM1vKAYbC+8gATe8X3+Oubl8Pu6rp4n2hYT0IFl6YS1E1Mm5ZMuw7VJVuFkgg5Z7pdPHJNtIjg73fP4txf/TPS9NSWhMMQVh6zMMHj0CjKy+LciUP56/zP0GN69IWzLqSQ/HHBcoKGyV8+WsnJg0v43VXnoSoK04f1i6z/u4WfRrYf91NalrEM+ZzjlgFhAaLIlDXBt6ecyCdle3lz25cYpkmO28MPT5rGzMFDbQ4oHpPyS3hr33rajPgAsVNRmVowoMPx/6047iPuPI659LWuQlXSk0gYrAql83vdz7icKfR0QoFTYUz2qdw44Glu6ncb9wz6DpNyJ5LlkHjUAG41iEcNoqkGy6qX83bF3C7NI2AaNAV8SClJ0zpu8x5fwkGcdeJSVbqnJQcLv3fGybhjxNRRQXMpFGRnMGPUYB6+5GxK8nOQLiuly3BG3Qe291wMeTX4fdzx7zmRCrmiblk8c+fFuN0aWqhdkV0RRoQbNSuPt0XV2dlQxzOLVyFdCppLQagCqYBDsy5nQ7XKlA3TxBvU+XRHKW+sTtaPmPdl6kIJTYqoloSN1W0VoVifACYf7dnDr0/7Bl/cdjerb76DVTfdzqXDRqTcfixOLRxMn/RuOGPK2RUEaZqT6wac2Klt/DdCmJ3/HOs4bhEfJgJGMx/uvxmvXoWCFxcqtd45HGgdxIDs85GyBZ++g1xHPQFVpUl3EwwF8IIyyNyK9/i8fgv3DLqVQndqvdlWPcCvN3zAvP2bMaWkuzuDB0afzXn9hjBv7/a4V1olJLigKgpGLAGbxOVNCyE4e9CgpH2dPnQAD19wFo8tWEptaxuqIrhg9DAemHEqHqeDNz7fzP625mjRRrgIQ0TLoBMRW3dRXtvAx1v2cObIgTz63hJmr9qI060iDcv6k36TgE3nZbtKujChuzSVc0YN4kB9M26nxtryioh7IFyJ14LOowuXUdIjl8n9orrFKX23AmadMIoFpbs41JZc6iwQlrRnaLgiBO4QaTtVFafauaab9f5WVtWU4lY1njvpOp7btZy5ZRsImganFA7mO8PPIN+d0alt/VfiuEXcaRwn4sPEprq/0xo8gElY2cvAkAZrah5jn7eZpdXvEpR+VAFuxcTlDFITyCQQk02xt7WMn23+LX8e91ucir2Ve9vyl9lUXxEh3EpvE/evfZvHJ1xCRUsTm2oOooRKg3umZ/LQlLN4fctmNlcfol92N9JUJ/N37sShKAgh0BSFf1x4UbS9UgLOGzWEc0cOptnnx+N0hPQnrEDbYwuSizYsBzBIvZ1YWshqDhomr678goY2L2+s3kRANyKZEwLQNAW3UPEFQkSauB2bHQghGDewN7+dMpp/Ll3LqjJLZzpcyhwe16YHueOlOfz8vDO4aOxwAC4YNZTnVqxLEtB3qiq3T59Inx7ZPL7k0xilNELzknFzcakqFw0bFvm9KeBn9aFyXKrK5B7FONVkkYm/bV/KX7YvRVOiT5k/TrqM+0eeleosfr0QjjEcR6dwnIgPE6UtCyIkHAspNT6pfhsjRvQ93CE+x9FGVcAKkFkuW0mz3sKvvvw9Pxt+H041noy/rK9kS0NlUiDHZ+j8dfsy3px5K1/WHmJ7fQ19MrOZUNALIQQn9S6OW//QtBbWVlSQ4XJyUp/iCLmmghAirnwZoKKhKV6ZLREqyIRsr0hwL+xzlrC2dD8V9U14EwhdYqW3XX7iaHaUV1NaXUdNc5vV0qqdpIOAblDfZvnLpwzow9OqQtC0KvbifN0C2gydH733ISv2lfGtaZO5eepEFm7bTUVDE95gEEVY7oh7Tj2RwqxMLhk5gieXryQYiPfdCgRSkdb6qsq1J5zAmEJLzOlfW9fxyLpPcIQkMAWCZ069kGk9o77pZYd28uyOZfhNHX/MKb1n1WwWnnUvea6vsRUci+NE3GkcJ+LDRCoRoDZDRUHBsCmIdYRaJksp4gJ4u1tLeXbPi9wz6Oa49bc3HUppZW5tOMgdK17lin7juHjA8HZTpHpkZHDekCEdHlN7yPK4MMx2iDimGCOCWH2I0E3pdGjUpFA2M01JSUE3vj/TKmLwB3XeWLWJP85fblX92aSwuR0a40usoOPwXj04ZWg/Ptm2h7awcyacXRH6vwTe3byVhdt38cr1V/DmbVfx/ubtLN6xh9w0D5eNG8XInlYlW47HzYtXXMq35rxLk8+PIgRCwPXjx9IY9ONQFS4YMpSRPaz1Vx0s59F1S/AbOv6YP/9tH7/Nkktuo8BjEey/d30WJ38ahpSSeeWbuG7g19cvHMbxgo6u4TgRHyaKM05jd9N7yIRcYiEMRIoYqOVWNEPdog0CpoYhFSSSVbXrubGklQxHNIjWOy0HexkwMDFZXLmDlVWlnF88iofGnXf0Ds4G3dI8TCrpzcq95XF92MDqI5fuclgC7CoJDTGJyWWz0tx6d8tme2VyZ2IJjOwd7ZzscmhcNmUUr63cSFltA4Fwp+TQKXFpKiN692B8v2j2x+NXnssrKzfw6w+XRNPbEk6hKaEtEOTXH37Mf66//NnqoAAAIABJREFUnItPGMHFJ9gH1kYXFbLsjlvYUlVNwDAY0aPA1tUA8I8tq20J1pQmb+3azB2jpgBQ5WtOWgfAb+opl30tcTyPuNM4njXRSUgZpKn5n1QcPJ39lSdR4mglXc1EFWFJLoEq3EzOvwm3ZvNqKVUaDA8uxcAZ+mRoflyKdeNqikZdIL4P2oT8vnR3pdsUdFiODVUxaTMCzC3byJaGzrUbOhI8dskM+ud3I83pwOPQSHM6GNg9jycvO4/fXXkeb99zTVLXighiCHHW5GQRGyFgbN+eDO3ZPe57p6bx0t1Xct208eRnpuFyqDhUlfzMdG4+dSJ/u/niuLcBVVG45qRxTOnX25aEY7Gu/AApGownzE0wokcBY3sWpSRhgAOtKQjWMOKWTc7vhyaSb7001cm4vOKk77+uON6ho/M4bhF3AlJKDtVciz+wGhlqRa63vsgJrjxa3XdywLsBt5rH4OxZdPeMJtdzMs/t+TmG1NHNIKpQaTYlEpFk4LpVnaDU0E2DfFe8+LsiBP+adh23r3iZHU3VxKodhLsOK4pJwDBYdGAHw3OKvtLzkJuextw7r+XzsgPsra2nX143xhX3jCPCZ667iPtnv0+rP4Av1L4IAQ5VQVUUHpl1Nj+auwDDAUK30r/CxRNNMkCL30+GK15vMsPt4q6zT+TEYX2RUjKuuCcurf1L9+JxI/isPFWDWAtOVT1qnS8AphT2YUdDdVJwL11zMLFHtAPGTYOm8k75F7To/shf1KGo9E7P4ZTCwUdtPv9fcbygo0s4TsSdgM+/HH9gTYSELQQwzTqKtBaG9Xo6bv0iTz9+OOzvbGlcTWOwhrX1K6hqOUAq88ytSqbnn0yalpz2VJSWzbeGTefBz+fQFmq/ntBtHoSwtbC+CgghGN+3F+P79rJdPrBHHpecOJLFO/eSn+ZhVI9CKuubKG9qpLShge+/O5+AblgpadGXCQA2HjjIlc/N5u3br44LKC7ZuZfvvPEeQdN6AClC8Mj5Z3HuSHu/t5SSv65Y3e5xaIpg5siOiy26gluGT+S1nZvQzViCVejuyeDs4ijBFqVlM/vU23hi8wJWVO/GIVQu6DOGe4efjvp/9Hf8v8Dx/ODO4ysjYiHEL4BbgerQVw9IKd+3WW8G8CSWXfQPKeVvv6o5HS68vsVIWzF5P23e98nJ+m7SEofiYkw3S8vinco3UhoHQkjyHWlcV3JZyv1nOz2RQJEdNKEwo/cw+4WdgJSSzw8dYH9TE0Pz8hmS173jQUBrIMDbm7fwaek+emRmcnr/fnx/zny8wSABw0AAa/cfoJvbTV2rNz5NLKwjkXBMBxqb+GjbbmaMsIhrX10Dd7w6N0mL4f45HzCgex5DeuQnzWvd/gNUNrfE5TBHjhVwKIJ+ebn86Myjq2xWlJ7FnPOu5aE1i/m0shRNKMwsGcqDE05PcmmUZOTx5ynfPKr7/6/DcYu40/iqLeI/SCmfSLVQCKECTwNnAvuBNUKId6SUW77ieXUJipKJ1fUxORAjRLIqWiI04UTFj55SuaYNJYUltLflIHta9+JxBvAaJmZMtoWUoAiV24dMpX9mMiF1Bgdbmrn63dc5GPJhGlIyvkdP/n7ORaQ5rHQ6U0rm7djOq5s24tV1zh88lLMGDOSbL79Gvc+LN6ijCsGrazeCKWMcKODTdSpbWmzV4OweLG2BIMv37MMQkmW7S1lXWmFpaCSsq0vJX5et4g+zkoOUu2pqMaSJ6bAKTWI5XAh48tKZnDb4/7V33uFxVFf//5yZ2V3tqkuWZUnuDWPTDMbYmGaajalOTCCEEkoILeUlbyD5JYG8abwhISEJBAKBlxRiB0gAG0wMGBtjMBg33HsvsnrfOnN/f+xK1mp3pZXVxXyeZx/vzsy9c8e7OnPn3HO+ZyR6nCrLrbGm5DB/27KGMl8DFw4exZmDinh9z2aKvbWcM2g4V40Yz6jMXF64OPFN9fOE7ftNnp52TUwGdiqldgOIyDzgaqBXGeJUzxeorvk9LevciXjISLulzfZn5pzLh6WLMa2WIkAKDUXAjNWNUErxxI7XePPwJ4SUhcsBA3STQNBDvd+JhSLfncGvJ83htNzjr8B7539eY291FWazuLNVxYf48fL3eHT6TJRS3PfmAhbv3t3k+1x3tJhffvgBlt+i0R1qKhVOV413kgR/kIluSws2bWXB1m00BIKJH28VbDhcHHfXsOyscPCaRLQumlWuF4EhuVntNsJ/2rCS365Zjs8M304/PrKfoLLQDTCxWHxwJ09s/IjXL7uFnBRPu/rulyjsqIl20NUOqftEZL2IPC8isWUQoAg40Ozzwci2GETkThFZJSKrSktL4x3SZTiMYWRn/RTBRdixqSPixuO+Eo/7yjbbX1FwA4NSCnGIhY6FRF6GhF8F7lhDurJiKwsPr8RvBTGVSUiFa5qluvzcNW4KL19wJ+/O+HaHjPCeqkq2V5RHGWEIr/K/vmMLAdPkk4MHjxnhZlEIAdMkpLf8Q2vHH14CN4sCGkKhpmohCXsUGJgRP/HhrGFDopXZGuOZI4k1b2/fmfw4gaMNdTy25gO8ESMMELAslFJNokMNoSDFDbX8au2ydvXdn7GjJpKnQ4ZYRN4VkY1xXlcDTwGjgNOAI8Bj8bqIsy3u16KUekYpNUkpNSkvLzkfZmeSkXYjRYM+IifzB2RlPEhB3gLych5PatXdpafw3XGPMjZ9Ak5Nw6lZODULXRROzcnVRV+JabPg0Ap8Vmy5JktZWFoD4zKPxds2hPx8Wr6HLdXJhWM1Uu5twKHH/wlYSuENBVm0a+cxI9yc5spuRESGmn1uE6GpxlzUK560ZYIub5sSv5CrJsKw7Hj3fRBN4uo7t8aSg7sTuI4k6tcatCze2LelXX33a2K+3FZen3M65JpQSl2czHEi8izwRpxdB4EhzT4PBg53ZExdiWEUkpH+teNqKyLcPfr7vF38KstKF+E16xmUMphrim5kXMYpMcfXheKXHbJQ1Dfb9/fdH/LEtsUYmoapFNlOD7+b9BXGZAyK2745J+QOCCdJxGGAJ5UMpyucqtua3WpWz07pkZA0iJb3lfCsx6HrGJHSRJYGKjKjPib8LrGzo2bp0Y32UxFO5rjohLBE5OaSEv65YQNVXi/TR47ksrFjue7Uk/j1shZFVAmHic04oX1C6xoJS83GkPSNqJ9jZ9a1jy5zTYhI86DW2cDGOId9CowRkREi4gSuB+Z31Zh6Gl10LiuYwyOnPMvjE//B9058NK4RBjgv72RcWqwwj1t3cvaAcBbYsqPbeGL7YnxWkLqQH68Z4LC3ijs+fh5fnAyvlqQ7Xdx52iTcLWJyUwyDH519ASLCNeNaicYQSNHCbUUkHAmhhfWAm6cXK11hOhSWUzFn4km4PQ4sQ6H0sPG2HGFfrqXFMWNCs9l35CUwMCsNEeH/1qzh2nnzmLt+PW9s386PFi/mmhdf5Krx4xiXN6BJ3EgAt2Fw66SJjM6NX4g1ZFnsqiqnpCFajP3CISNj3DdhohcRdREuHdJP4oA7ilLte33O6crFukdF5DTCfzt7ga8DiEgh4TC1WUqpkIjcBywiHL72vFJqUxeOqc9wWeFkXj24nKP+KoKRWmYuzcHI1EKmDgirhz2/a1lcg+szg/xt94fcMfr8Nl0n9585jcK0dJ5c8wklDfWMzMzhwSnnMn3YSADGDxzI1KLBrDgUnRwhwMn5+VwzZjwf7tlHfTDAZ0eL8RFCzBYzw4hBNpw6ZwwrYu6G9XGra6CDshSiwipxjanUjfq/jdMGl6HzhVPGU1xby6MffBAVFtcQDLK3qooX1q5l7g1f4u0dO1m0fSdpTidzTp7A6UWFcf8fXt6+gZ9+soSgZRJSFhPzCvjD9KvI96QxwJ3KjyZfyM9WhvebSuHQNELKQvTwlaboBukOFw9OPD+mb6UU7xxdx9y971MeqOXkzGHcPupSRqa1/dTSl7FnxMkj7fEp9hYmTZqkVq1a1dPD6HLqQl5e2b+M946uRdc0ZhZMZnbRNJyRUkozFv+Ko76auG0dopOXks7vz7yR0ekdK8duKcV/L3qLBdu3NflXJxUW8cSsK8h2h5NQ6gIBpj39DHWBQPMEwKgFPqeus+xrt3PJcy9QGwjEGmIFLtH59tlTQYSlO/ZQ4/exp6KSkFJYSuFxOBiek8W8m67j35s384v3349xPwAUZWSw7I47krq+JQd2c/fi1/A2Kz2lizAkPYslc+5ouuatFaXM3f4ZpQ31TB8ykuEZ2czbuY7ihlrOLRjBl8ecRqYrtojA0zsW8sqBj5p8/oLg0h08ccZdjMs4/sXW7kBEViulJrW3XXrWYDXxvG8lffwHCx5o8zxt5RyIiAv4K3AGUA5cp5TaG9n3feB2wkW3vqmUWpRMn91FT4ev2bRCmuHmqyNn8NWRM+LuH59ZRImvNq5fMqhMDnuruH3Fcyy66Ltt1sFrDU2E38ycxY+nX8iuigoGpqZRlBEdP53mdPK3a+dw52uvU9HQEBb+aWZoHZrGWYMHk5eWxti8Aaw+HGcpQOCSE0Zz59mTAbhz6pkAbDlaysufbaTa52P66JHMOGE0Dl2PW3CzkXj7lFKsKTnMe/t34zYMrhw1jmEZ2Ty+9sMoIwzhcLxSbz0fHt7HuUXDARiXk8f/TLmYmoCPqkADBZ7MqNTleFQG6njpwHIC1rH+FQqfGeAP2xfw5KS7W23fl+nMGXGSOQe3A5VKqdEicj3wS+A6ERlP2O05ASgE3hWRRh9Sr8hjsA1xL0EpxbqqD1ha+iq1wSqK3CO4dNANDPEkXlj6+pjprCjb2ao/OGiZLCnewmVF8X3R7SHDlcLEgviP9hBRKrvzDp5Z+ykvrFtLdYOPFAwsSzEmN5dbJ5/Oy1s3MmHQQDaVlMTMZD0OB9NHjYjp98T8PB66dHrUNksppo8YwSPvvx9zvFPTuKKF7KdpWdz33gLeP7AHbyiIoWn8Ye0KHjzzfPbWVMa9npBlsbu6oskQ1wZ9fG/VfN4v3okuGoZofGvCBdw8enLC/5P1VXsxRCcQp+L3xup9Cdv1eRRhmbvOI5mcg6uBH0fevwI8IWHf3NXAPKWUH9gjIjsj/ZFEn92CbYh7CW8fncfy0jeaqkLvqFvP3l3buG3kDxiROj5um3GZBTw1+RYe2fgG22vjJzf4zRDFvqq4+zqbKp+Xa1+fx+G6GrxmCJdHJ4TFw1Mv5C+b1nD32/PD6zJKYSmi/MBOXacwI53LxkYvdh2oqWLFoQNkOF1cMGwE2yvKefiDxaw7egRd0/A4DYI+aZoBuw2DgWlp3D052ji+vmsL7x/Y06TX0Zic8uinyxiZnU2VPzZKxdCEUVnHFva+9uFcNlY2CvWH/dKPbXyPTEcKVw+Lf6NLN2JdFY2k6G3XHuzTtM8ODxCR5v7GZ5RSzzT7HC/n4KwWfTQdE1l/qgZyI9s/btG2MV+hrT67BdsQdzFKWfhCOxF0XMbIuItnDaFaPiidT0hFz2yDys+CQ//HN8f+KmH/E3OG8dJ59/LtT1/k/ZJtMW4Kl25wQkb7VdlWlx7kHzvXUOn3cnHRGGaPOBm30bp740fLF7O3urLJyHkjM96HP1yMaVlRqmR6isYgRxqhgIWuCVefeCL3TDmrSVVNKcUP3n+Hf23bhK5paAimUgTMUJPecciyqCEADjBMjYLUdO6cdCZfnDAhphTUi1vWNRnh5oSUxbjsgeyurohyTxiike9J5+yCsCzl1uqjbK4qjqmW4jWD/H7L+wkN8anZI3HpDhpMf9R2p2ZwRcGZrf5/9nXa6Zooa8NHnEzOQaJjEm2PFzXWI4tm/dIQK6sWxIFI4tlId1DjW86+sv/CVLWAwtAGMGLAE6S6JkYdd6BhB7o4YgwxwGHfXixlJdSiaOSusRfycfmuKDeFIToF7iymDGhfSfYnNiznqc0r8JlBFPDJ0f08t3Ulr874KhnO+P+nIcviP7u3x0hAooi7mGYqi1KznhW3fp1cd2xK8MtbN/Lq9s3hQqBmbLWTKDQIaRalVj1nDimKW4/PG4zvvjEti3xPKv97zkz+55PFeEPh6s+TBw3m8QuuaFqo21NbnlAZ7UhD/AVTAF00fnXarXx7zZ8xlUXICmFoOmPSCvna6Gjfv1KKDdXLWVb6L2qDFRS6R3Nx/g0UteKe6tV0biBAMjkHjcccFBEDyAQq2mjbK/IY+pUhVoGVqOqHwNwPCMp1LpLxM0Q/PkGcjuAL7mF36e1YzaQzA+YBdpTcwITCZTj0Y9mBbiMNRfzECoc4k0onGJdZwB8n38wjG99gV20JumhcNGg8/+/kK9s04s1ZW3aQxzd8EBbaieA1gxyqr+bpTSt4YOJ06oMBnlj/Ef/avYGgZXHx4NF845SzYytztELJH5/Du2krA+66P+k2jbgnjGPgPbfHbA9aJov27GBcHPW4WSNPYFd1RVOF50ZchoHhEBxOWDrnDqr9ftKdLrJToiVJh6flJLy+fHd6q+MdlzGE18/9IR+UbqLcX8OJmUM5OXNYzNPReyVz+bB0fpN7amfdWvbVb+bmEQ8xPIF7qteiOl0GsynnADhEePHthhbHzAduAVYAc4D3lFJKROYD/xCR3xBerBsDrCQ8U26rz26h3xhiFdyCqvga0ExAx78MVXE9DPgP4Rtk91Fa+39YcWa4SoUoq5tHQeY3sJTJntq32FL5EiOc+6k2HZQEM7AiSumGODgj54KkxctPzxnOy+fdh88MYoiGobVeJLQlDaEAX106FwuLlk9zActk/r5N/Ncp53HFm89zoL467N9V8OruTSw5tItRWTnsqCxP6lzeTVvbNbbW2x4TvEx007p5wun8c9sGShrqmoyxoWkECPL8jk/Qdob9zI9NvZKZQ2J1ik/MGsS4zIFsqjoSNet36w6+eWJs7HBLXLqDiwedlnB/Q6iW5aWvxXVPvXn4z9w75jdtnqM3Ec6s67wZcaKcAxH5CbBKKTUfeA74W2QxroKwYSVy3EuEF+FCwL1Khav79pY8hv5jiOv+CLRccAmBVQ7+pZCSVDZ2p+ENbgufvwUKP77gNpRSLDn8XY40fIzCwhDI0QNk6/XsCxQSVG4K3SOYVXBTu899vKFq8/dtxG/Fjrk5MxY+y76GCpSAROx8KGRSG/QzfehoDtZW4wsdE8dxOwwuHjqKd/fuavIZN2fYXx9p1xj33fz9+DtSLJSCc4bELzWU4XTx5hdu4a+b1vDG7m0ELZMD/gpMLYS32ST5/hXzOSWnkMLUWHnTZ6d9mQc+fZ0PS3ZjaDoawjdOPI/Zw09t1zXE45A3sXuq2LcXS5lo0r4ba4/TycLwET3zhS22PdTsvQ+Iq0GqlPo58PNk+uwJ+o0hJrSJuH521QChbUD3GmKP82Tq/KtoqWEskoLHeTLF3lUcaVgZ5ZKQiDrYKFcl5xQ8wtDUsZ1ayqct1pQdJKhM4q1tCJDqcLKrprxJxQwiGhC6wm+abK8p5d+zv8LvVn3EhtKjFKalc8/pZzF96Eje2LmVX6xcSqm3joHuNDoeuNXsu3ZZ4VRqLL7+/r958IzzmTHkBNKd0SWXMpwu7ps4lfsmTuXWpf9kz5HYKtkhZfHa3g3cM2FazBkznW7+NO16Kv0NVAYaGOzJwql3zp9Qit6ae8qRsCBtb6YzZ8T9nf5jiPWhYMapUSZu0OOX9QFQVh34F4cNtnMqYgzvlOEMTL+VsroXW7gnBA0nuanXsab8+ZgK0I1Y+EgzrG41wgBD07Jx6To+y4xW7EGRZrjYW1cZ5TuG8M2jUX9tgDuVE3PzeHrG1VHH7Kwq4+HVb+MjhHJaVFHf8cEaCjQVfqCU8HslUBao44crF/HQyrf5w7lXc9HgMXGbH66vjrs9ZFkcqGs93C/b5SHb1bmaw4PdY3Dr6QSs6Kc6XRycln1ht/8WOoytqtYu+t5tNgGS+nUgtuYbOCAlfmaa8i1BlUxDVT+MqnkEVXYlVvVD7ZKSTITTKGLMwHmkOMYiOBEceJwnM3bQvzH0LAxxJWwrCN5Qcr7WzmTOiFPRRUPTw7PcRgktp6Hxh3Nmt9rWZRjcMi5WllIpxe1LXqHC30B9KEBIWdTHCSNrNw4VnkY0EwVqtFV+M4TXDPKND16j0h8ucbW5qpgHP53PDUtf4PGNSwgXm473Pau48qNdjYhw0/Af4tEzcGpuDHHg0FwUukcxs+CWbh9Px7FFf9pDv5kRi2sqKuOHUPsLwlJdJuh5SNZTiMQaaGVVoKq+RYxf2fs6OCeB+6oOjynVdSrjC94laJYh6Bj6MY3cERkz2VT1d+IbAyEnpXMLW8ajIeTjveJ1bKzZz1BPPlcUncmfzvkS31jxL0wrvGCnUPz0jFmcWzCSXJeHYm9syXgB7jhxMucVxmbFba0qpdRb3/mTI7FomkeISljP7819W8lMcfKD1QsImCYWivUVh1uoqR2rmCLSM4YYID9lKN8d92e2166mJlhBoXskQzwnICIopagPfEaV9x0EBzmpV+B29O6wNlv0J3n6jSEG0DzXotxXQXALSCoYoxM/0vneStCLF9XwV6QTDHEjjjjhc9muUYxMv4zdtS3XCTRGpV+Bx+jakLtVFdt5YN3zBJpFADy9cyH3jrmcT666n3XlBwkqi9NzB+OK+EEfOuMS7l8xH1+UOI7GSbl5ZKcalPhqGZgSHcpVG/Cjd8VjtQ6YkVj9BN37TZNyXz2/3vxO1JgbkzIMh8KyBMsMG3RdtzAMEyuBy6g7MDQH4zOnRG1TSrGn4rtUNryJpXyAxpHapylIv5uirOSFdbode6abNP3KEAOIuMCZOEyoCasaSDDzsbonJXjaoIfId5/G2vKn8ZmVOLV0JmTfzITsrg1lrA/5+N5nL0QM0jErZqF4audbjM8cyqS84THtZg4ZR6rh4jfrl7KzppygCuEwLLbWH2T3liM8uXUpv5v8Jc4bdMwve1JOflMac6fS6JJQKvwUDDGzYpdhkOlyobUSh+1wmIgzOra4JhRbQ7AnqfK+TWXDwmYx6SZKmRTXPk2252I8zgk9Or64dH4ccb+m3/iI241zMsTNvDPAeW63DWN05lVcO3IhN41ZwXWj3uaknBuRdiRgHA/LSzcRsuJnq4WUySsHlidse27BCF6dcStzxpyI0xkiJGF/b8Ay8Zkh7v/0lajsPo/DyXcmno+7WUhdp82PNZXwF5yiG0zKG8y47Dzau2qUlxK/Fl5PUVo3D0s1xGy3lJ+yun/3wIiSxPYRJ02/mxEnjeMMcJwKgbUc8xNrIB4k7es9ObIupzbkjYjkxDeJpQk0jpvzxoENkVC3WFaU7GZ6wTH1szvGn8mIjGyeWP8Rh+prOCknn/87rpE3oymHI3wdozNzGJ6ezbryw3gMBzeMmcht4yYjQtzMQg0Jhwu2+C9w6w5uGJlYTS1Zyv0lLC97i8PefRS5h3NO3kxynAOPqy9LJYoysbCINdC9Btu+Js3n1hCLCGQ/i6p/Hhr+GQ5fc52PpH0T0ftH5YSgFWRpyWKWl71PSIWYlD2ZSwfN4rSskeiiYcWJGdYQzsxtu9xPKIERBuImhVw0eDQXDT62uNRRQ5xqOLBQFKVm8tjZV3DqgMTynL896wvcu+JlTGURtEzcuoN0h4uvjjmTJ7ctRZPwoqRScMuoqUzJG9mhse2p28qze36BaYUwMdlbv42PK97lzpE/YHjqCW130IJsz5XUBzZEpcsDaOIh2x0/Iqg3YMcRJ8/n1hADiDiRtLsg7a6eHkpCGoJ78IWKSXOOxanHr7UWD0tZPL79V+yr30NAhX3h7xz9DysrPuZH43/K2XknsqxkU0St7ZgxTjPczB48Naov0zJpMP2kGilNs8tpA0ex5Mj2mLjikGVx1oDY6InO5qUZN5LqcDI8PafNY88dNIpFM+7m5T1rOVBfxRm5Q7hy2MmkGk5mDz+NJUe2EVIW5+WPodCT1WpfISuE1/SSaqTGnWkrpfjH/icIWMfU1kxCmFaIufuf5HvjftfumOABqXMoqfsb/uB+VOTpTRM3aa7TyUg5r119dSu2IU6az7UhbkQF1qHqHoPgJtBywfM1xHNtjwbRB8wy1h+9h7rgNgQHSvkZlDabE3IfRpJIdd1UvYH9DXubjDBASIWoCVazrHQJPzn5JubuW8rf9yyh3vSjicaU3BO4f9xsspypAAStEM/tfoM3Dq/AVCaphptbh1/G5UVn88BJl/Jp2T68ZpBgxN/s1h3cO+78Tk92iMeEnPY9tRR4MvnmhAtitue60pgzPDb+uSWWsnjpwKu8fXQJpjJxag6uLpzF5QUzon4nFYES6kLxk0VqgpVUBcvJdrYvIkbX3IzPf42SuhepqH8NEQd5adeTm/rFLl9POG4UnZ7i3J/53BtiFfgUVXE7TX5isw7qfo4ydyIZ/6/HxvXZ0a9TF9gayb4Lj624fj4uPZ8R2fe22X5D9Wf4LX/M9qAKsrZqFTMLLufG4Rdy4/ALE/bx2LZ5LC9dj98KL75VB+t4atdraJrGZQVTWHDRPbywcwUfl+5hoDudW0ZNYerA6Mf63XVHeWr726yt3EuG4eb64WfzxaHHwrMSakf0Mv66bx7vl35IIBJjHDJD/PvQAiwUVxVe1nSciBa3dBWESyS1RwmvObrmoSDjaxRkfO242nc3grJdE+3ANsQ1PycmqUN5oeEfqNQ7e0RCsy6wnfrgrpgUaEt5OVD7QlKG2KN70NAiSmot96W22b7cX80HpZ9F1VoD8FtBXtizkJmDzmKgO50HTr40YR+7aou57eOnI7rGipqglye2LWJT9UFmzZrFwoXHp7Uya9aspvf1IT9vHlrJh2VbyXamMXvwFE7N7lzXSH2ogaUlywm2EOTxWwHmH17IrEGXYGjhP6UcZx7ZzjxK/bGytrnOQWQ62nal9BtsQ5w0vfS5pntQSkFoS/xRvSB4AAAWeElEQVSd4oTg+uPv26rBqv0VVsl54Vftr8OC9UngDx1BiO9+CFk1qFYWyhqZMmAaehwXhlNzcX5e4llwI/sajuJIIB1aEajl3tU/Y1lp65W0n9z+Nj4zEDVD9FlB3iveyB9f+gtKqeN6vfnmmwBUB+q5ecVveXrnIlZV7OTd4nXcv+Y5/rL7vTavrz2U+EsTSoqayqQ2VBe17cah38SluXFIOGTPECcpmpsbht3XqePq9djha0nTJTNiEfkn0Lg8nAVUKaVisixEZC9QS7gAWOh4ynZ3BBFBiQfihgdZoLW+cJMIpbyo8jlgHqJJfa3+BZTvHRjwepuVQ1KdJ6CIr8eQohcl5SMelFLAFwdfz78OzgNoqvIxNXcap2ZNbKM15LuyE4angeKg9yhP7PgHR71lXDt0Ztyj1lXuTZDALayr3Muw1I49bbyw5z3K/TVN41SEDf0LexYzq/AM8lIyO9R/IznObEIJ5UGFNCP6CaPIM4LvjfsdKyve44hvP4Upw5iceyFpRqy0Zr/F9hG3iy4xxEqp6xrfi8hjQPzVizDTlVJlXTGOpHB/CRr+ATT3pwpIFjjaztBTZjnK+08IbgZjLOK5DuVbAuZRoiUwA2AWg3cBeOJKpob7Uwrd3MNIZyYB8xBVplCjdEDQJIVR2f+d9KVdmH8xp2VPZG3laoJWkFOyTqXQ3Xr590aKPHmMSx/K5pq9LULVFIZYiIQfzV86uIjLCy/AE6dIZprhoi4UW5RTE40MRzyBpvaxuPizuDcLDeHDsi1cM3hKnFbtJ9ORwWlZp7CuakOUe8IpDqbnnYtDi9V/TndkclF+60JJ/R3bR5w8XeqaiJSy/hIwtyvP0xEk/X5wngmkAO6wRoWWi+T8uc0VaRXciiq7BOqeAv/bUP8MqmwG+F4jqlJIE16Uf0mrfdZX/5CailtIVXvJ1gIMNfyMMPy49HzG5f6M/LRZrbZvSY4zl4vyL2VmweVJG+FGfnzSbZyUORKnZtCoa2iIhUM7NtUxRGdv/aG47ecMnUpKHCOliXD2gLZjldsi8cKXoHXyT/uuUbdxatZJOMTArbsxxGBK7mRuGDqnU8/Tr7BdE0nT1Yt15wJHlVI7EuxXwNsiooA/tSifHYWI3AncCTB0aPwqDMeDiAvJeR4V3AzBjaAPBOc5SZVWUtUPgGruHwyACkBoK406vtFo4fC4BAQDq/E3vERzI64LZIiTgsxvkZJ6ZXsurcOkOzz86rR7ONRQyr2rf45FKCYTzVQW6Y74i383DJ/GpuoDfFS6DZCwxKbA42d8FddxVhFpzsyCifxz//KYBUULi3MHjsdvBni/dAWfVnxGmuHhkkHnMz4jvj5xW6ToLv5r7D1UBqooD1SQ78oj3dF6rbrPN7aBbQ/HbYhF5F0gXjDnD5RSr0fef5nWZ8PTlFKHRWQg8I6IbFVKLYt3YMRIPwMwadKkzldVdIwHR/IFGpVZDqHdiXYCDmJFhZyI50sJ+ww0zCfaRdKIF7/3JVJSv5j0+DqTIk8eF+Sfzgelq6PcFIKQ58qm0B1brBPA0HR+OfEr7KotZl3lPjKdHs7JG3fcpZxactOI6Swv3UyxrwqvGUBDcGgG942ZhUvTeXD9z6gIVOGPhJytrlzP5QUXc93Q41fWy3Zmke08vrWDzxUK2xC3g+M2xEqpVmsPRcpZfwFIGC2vlDoc+bdERF4FJgNxDXHvo7UfmQaeG6Dh7zTXuiX924jj5FZ6DLXSb8+tfHjNBnQOoosfU4UXCgVBxMRSe/nOuruZMegKZg66Mm4SzKj0QYxKb18CxsGGw7xdvIxSfzkTMscyfeA0Uo3oRJFUI4Xnp3yL94rXsyISvnZl0ZmMSi9g7v7XKPNXEFTHZst+K8CCw+9wwcCp5KfEv3nYdCL2Yl3SdKVr4mJgq1IqTv0iEJFUQFNK1UbeXwr8pAvH06mIPgClDwMzjtdFy0LSH4DUW8C/BBBwTUf0/Fb7dLmvxO99Oax7EXUyNy5Pz8yGAV7Y8zv2NGxhUEqIgGUQsHR0sXBoISx0fBa8VTwfC4vLC67p8Pk+LP2Up3f/lZBlYmGxsWYr8w+/wy9O/h4DXNFxuE7NYGbh6cwsPD1q+0dln0YZ4WMoVleuZ1bBRR0ep03rSFfIn/ZTunKx7npauCVEpFBEGqP484HlIvIZsBJ4Uyn1ny4cT6cjWb8ML+7hjGwxwuptWb9GRBB9EOL5MuK5vk0jDGA4z8KZMgOk2cxPPBiOk3C5v9Al19AWFYEydtZtwVRh/7BLD5Hu8OMxghhyrDBZwPLzTvGbrYR5JYffDPCn3X+LZLCFMCSEqXzUBmv4696Xk+4ncbFN6ZOFOPscCrBU8q/POV02I1ZKfTXOtsPArMj73UDH65D3IOI4CQa8hWp4MaxTYYxFPDciRvuiE5r6EyEt6/cE/YvxNfwTlB+XezZO9xWIJParKqXwB1YRCu3B4RiLKxlh/CSpDJRhiBG3zHtLLGVRE6omx5m8OFFLNtdsQxPBpQXRomrthNhQvZJdddMZmTomoQ7IwYY9LClZiC51aEiMKBEozszp0z+7PoK9WNcePvcpzh1F9EFI+nc6rz8RnCkX40xp1QXfhGmWUlx6LaGmCtYWDseJDBowF03reAJBvquQUNxH/FgUkGZ0NJJAAD9a3Dp0Jo9v/yXjMsZz16hvx2QOrqv8hL/v+yMhFcRUCk3SUEpDRcLZDE3nS4OvjHFv9DaUCoBvESrwGRiDEfdViNa7xxwX2xAnjW2I+zgl5XcSDO2CZroUgcBGyiq/w8DcZzvcf5ojgzOyz2ZN5QqCzZTclIKQaqxXBA5xMm3A+Tg1Z4KekmN8xlggkLAYqM8Ksq12M8tKFzN94DGdC1OFmHfg2aYxagK5zjp8lgOdLCblTOXC/GmMSO280MeuQJllqIprwaqMrBWkoOoeh+w/I85uTTztOLYhThrbWdaHCYUOEwishZhilwEavG9jWYkqO7SP64bewTl5l+DUXBhi4NHTKEgZjiYuUiKl3yflTGHO4I7X2nPpTlx668Y8YAVYVhqtJ3GwYS+Wil4cEgG3HiRFL+fGYbN7vREGUDX/E87KbFqw9YFqQFXel5TGSK/B9hG3C3tG3IcxrQoQB6jY2GNBw1I1aLSttNYWuhhcU3QjVxZej8/04dY9aKJRE6ymPFBGnmtgJ7gkjnFK5smsrlwdV05Si2xrKfGpS2P2Xzyk9+r2NkMpC/yLib2xAvgh+Bk4T4+zrzeiQNlRE8nS+3+dNglxOEaTyPiIloautR2p0R50MUg10ppSizMcmYxIHdWpRhjgi4O/SIqWgkSVcVJohP3GOjqnZkYbpEL3UNx6rCC9oDE67cQOu0y6B4vEwbcCKla3o1djpzgnjW2I+zCapJCV8R1EogV0RNxkZz7UJ2aB8RiUMogfT/gxZ+eejUtzogGGWBhiNd0MZhZEp3tronHriG/j0lJwSNjoOjUXaUY6Xx52Zw9cRfsRMVoRmjLB2bZqXq/Bdk20C9s10cfJTL8bXc+nquY3mOYhDH0E2ZkP4unFRSWTYWDKQO4YeQe3qdtYWfERS0vewWt6OTVrIhfnzyLDEStxOTx1DA+N/x0rK5ZR4j/CUM8ozsg+G5feuuxob0IyHkZV3BBxN4UIL4amQPoPY264vR57pps0tiHuB6R5vkCap2cSPjoDb6iCI961GJJCoWcShuaiIVRGfbCEDOdgpuSew5Tcc5LqK82RwYX5V3TxiLsOcZwIuQvC1cWDq0AfgqTejvQZ33AzbEOcNLYhTgJlFqNqfwv+98KLY+7ZSOo9iNbxhbD+gqVCBK0qHFoGmiTvj11T9hwbKl9EwyBc6UyR5RpOpX8nmjiwVJCxGVdy1sBvoiUhiN8fEGMwkvlQTw+jg9i+3/ZgG+I2UFYFquwaUNWAGfZ91f8F5f8Qcl9JSi6zv2FaXvZX/YGjda9gKj8uYzC1waNYkUfpovRrGZvzXbRWsgEB9tctZ2PlXEwVwGymVFfm2xw+TyQmeHvNm7j0dE4fcEeXXZNNJ6MAW2siaT5/VqSdqPq/RDSHm8dwBsDcGxb0Sbmkh0bWMyhlsaH4JuoCW1ARyc6G4DZ0BaHIrPZQ7cuErFpOynuk1b42VM4llEQkgKl8bKp6iYm5t8VdgFTKpNT7AeXej3BoWRSlXY3bUXRc12fTidgz4qTpm8vq3Yl/GbG6woSD7P0fd/twepoq30fUB7c3GWE4JvRpRG5WlvJxtG4hAbO81b68oYqkz2tagbhG27R8fHLkK6wv+W/21/yd3VV/YvmhKzhcuyDpvm26CDt8LWlsQ9wWWrjA5RU3HkIv2BH9ynoorLLWxuvyyy/v4YvoPKp9q7FaynQSzmLTmsU0a+Ki1r+Bw9VPsr3kDvZX/hxfaH9UmwLP6QmrVbfEoaVixIka2FP9HLX+bZiRMSmCWMrPpvKHCJhV7bk0m06lHaFrdviabYjbQlJvBnHz1uJY45MsCxcubPugPoJTz0FLUIVaRSVgNLCv/Bscrv4D1b53OVr7ApuOzKDae0z3/5ScGzG0FIhqJy0+gyEpEbdErADFodp/Y8WpaiJolDQsbseV2XQqKuzGSvb1ecf2EbeBuM5FeW4Dvg2AeaR9Nc/0gkTl+vomealXsKfy0ZjtSoEZua8LTtJ0DVNVcSzzL4ilguwu/xanFa1CRCfdUcCVQ5/h09InOdywGl2cjEq/FIXFjpqFgEITnTGeMeTp1YTMcgw9WmLTIr48p0JhJSHdadOF2DPdpLFnxEmgpX+rp4fQa3Do2Ywf+BS6pKJLGpp4AB1LHIiko+Ek1z0VVA3x0q8tFaA+sKHpc5ZzGJcUPcotYxZz4+i3mJr/X5yd/x1uGPkqk9MymejaR6q5gKPVv2DrkSnUeN+N6m+g5yIk7nxCMcCdXOyxTRfRTT5iEckRkXdEZEfk3+wEx90SOWaHiNzSbPsZIrJBRHaKyO8j1ecRkR+LyCERWRd5ta+EejuwZ8Q27SbbfQ5nDfmESu8HWKqezJSpaOKmIbSfFD0fh5bO6oMTOnSOirrnMEMbUIQX6BQ+ULC//G5OLFyLrqUBMDrrHkoaFhMya7Aii6q6uBmS/mU8juMT6LfpBJTqzvC17wGLlVL/KyLfi3x+sPkBIpIDPAxMIjxDWC0i85VSlcBThCvEfwwsBGYCb0Wa/lYp9euuvgDbENscF7qWwoDU6NC9TP2kpvdprtOp86+i5axYxEmqM3EB1UYq6+c2GeGo9mjUet8lKzVcG89l5DGtaD77a16ktGEpDj2LYRk3MsB93nFclU2n0n3REFcDF0Te/wVYSgtDDMwA3lFKVQCIyDvATBFZCmQopVZEtv8VuIZjhrhbsA2xTbtQZgn4/gPKC65zEcf4uMcNz3mELcVfxFK+SKibA00MRuU+jiSRIWcpb/zzY2GpaJ1lp57F6Ox7GZ19b7uv53hRVgWq/kUIfApGIeK5OeH/xecV1b4Z8QARWdXs8zNKqWeSbJuvlDoCoJQ6IiID4xxTBBxo9vlgZFtR5H3L7Y3cJyI3A6uA70Rm0J2ObYhtksZqeBVqGlNvQ1D3JCrlEiTzVzGJFm7HaE4ufI/SurnU+deQ4hjBwLSbSXEMS+pc6SkXUNXwOjGykMoiLeXcjl9MB1Ch/ajyOeGbEX4IaijvQlTGT9A8Ha9i3T9ot++3TCmVsASJiLwLDIqz6wdJ9h+v5otqZTuEXRY/jXz+KfAYcFuS52sXtiG2SQplFkeMcPNQMRP874JvPrhjDZBDz6Uw877jOl9+5gPUet/DVPU0CqVr4iE79TqcRs9W2lA1P48sRjbeJCzABzUPo1IuRbRYXeTPHY0ymJ3VnVIJiziKyFERKYjMhguAkjiHHeSY+wJgMGEXxsHI++bbD0fOebTZOZ4F3jje8beFHTVhkxy+N4krQq+84SrWnYzTGMKYQe+Qk3YjTmMEHucZFOU8RkHWTzr9XO0m8AFxBdxFh+Cn3T6c3ogClGkm/eog84HGKIhbgNfjHLMIuFREsiNRFZcCiyIujVoRmRKJlri5sX3EqDcyG9jY0YEmokMzYhG5FvgxcCIwWSm1qtm+7wO3ExZp+KZSalGc9iOAeUAOsAa4SSkVJ5/YpqdRVj0kiNnFquuSczqMQoqyf5ZgPHUgTqQdSm+dR4LKpoD9kBlBdWuppP8FXhKR24H9wLUAIjIJuEspdYdSqkJEfgo03il/0rhwB9wNvAC4CS/SNS7UPSoipxG+r+wFvt5VF9DRX81G4AvAn5pvFJHxwPXABKAQeFdExqrY6oe/JBweMk9EniZsuJ/q4JhsugBxTUM1PBfxizbHASkJnxo7HRVYhap+GMzdgKBc5yMZP0X0Ad02BlwXgf8dooWgABQ4z+y+cfRyVDcldCilyoGL4mxfBdzR7PPzwPMJjjspzvabOnekiemQa0IptUUptS3OrquBeUopv1JqD7ATmNz8gMhjwIXAK5FNfyEcNmLTG3GcDs4phCcNTRtBy0JSb+2WIajgNlTFbWDuIGwEQ+B/H1VxHaobs+gk44cRDZLG/wsHkIJkPtZDM/ReirKSf33O6arnqCLCwdGNtAwJAcgFqpRSoVaOaUJE7iQcdA3gF5Eu89e0xvGmLMfTSUjAAKDsuE7SY+S2fUiXXtcWoEcNYOTaYiZl/YETjqdRLZWL3lWvtOcxpY/95juXNg1xa2EjSql4TnFoPSSkPccc2xGOKXwmMqZVrYW69GX667X11+uC/n9tx9NOKTWzs8fSn2nTELcWNtIKB4EhzT43hYQ0owzIEhEjMiuOd4yNjY1Nv6erwtfmA9eLiCsSGTEGWNn8AKWUApYAcyKbEoWd2NjY2PRrOmSIRWS2iBwEpgJvisgiAKXUJuAlYDPwH+DexogJEVkoIoWRLh4E7heRnYQdjc8leepkUx/7Iv312vrrdYF9bTYdRJRdpsTGxsamR7Ez62xsbGx6GNsQ29jY2PQwfcYQi8i1IrJJRKxI6mLzfd+PqOtvE5EZPTXGzqA7qwJ0FyIyM/Ld7IwId/cbRGRvpLrDuuMN9eotiMjzIlLSPEY/2eoXNh2jzxhijqVTL2u+sUU69Uzgj5KM4G3v5rdKqdMirz5deTTyXTwJXAaMB74c+c76E9Mj31VfjyV+gfDfUHMaq1+MARZHPtt0Mn3GEHckndqmR5kM7FRK7Y4IOs0j/J3Z9DKUUsuAihabryYsPwC2DEGX0WcMcSskUt7vy9wnIusjj4p9/VGwP34/zVHA2yKyOpKG39+Iqn4BxKt+YdNBepVmXxemU/cq2qg20G1VAbqJPvf9tJNpSqnDkfI874jI1sjM0sYmaXqVIe7CdOpeRbLX2dVVAbqJPvf9tAelVGM1hxIReZWwK6Y/GeJkql/YdJD+4JpoM526L9GdVQG6iU+BMSIyQsIakdcT/s76PCKSKiLpje8JV33o699XS5KpfmHTQXrVjLg1RGQ28Acgj3A69Tql1Ayl1CYRaUynDtEsnbqP0m1VAboDpVRIRO4jXKpGB56PpMD3B/KBVyMSpwbwD6XUf3p2SMePiMwlXNdtQES64GESVL+w6VzsFGcbGxubHqY/uCZsbGxs+jS2IbaxsbHpYWxDbGNjY9PD2IbYxsbGpoexDbGNjY1ND2MbYhsbG5sexjbENjY2Nj3M/weGleyzh8+OUgAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -926,16 +923,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "It's now time to build the neural network that estimates the likelihood ratio. The central object for this is the `madminer.ml.MLForge` class. It defines functions that train, save, load, and evaluate the estimators." + "It's now time to build the neural network that estimates the likelihood ratio. The central object for this is the `madminer.ml.ParameterizedRatioEstimator` class. It defines functions that train, save, load, and evaluate the estimators.\n", + "\n", + "In the initialization, the keywords `n_hidden` and `activation` define the architecture of the (fully connected) neural network:" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ - "forge = MLForge()" + "estimator = ParameterizedRatioEstimator(\n", + " n_hidden=(100,),\n", + " activation=\"tanh\"\n", + ")" ] }, { @@ -949,15 +951,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We will use the ALICES technique described in [\"Likelihood-free inference with an improved cross-entropy estimator\"](https://arxiv.org/abs/1808.00973). Most other methods, including RASCAL, are described in [\"Constraining Effective Field Theories With Machine Learning\"](https://arxiv.org/abs/1805.00013) and [\"A Guide to Constraining Effective Field Theories With Machine Learning\"](https://arxiv.org/abs/1805.00020). There is also SCANDAL introduced in [\"Mining gold from implicit models to improve likelihood-free inference\"](https://arxiv.org/abs/1805.12244).\n", - "\n", - "Most of these methods exist both in a \"single parameterized\" version, in which only the dependence of the likelihood ratio on the numerator is modelled, and a \"doubly parameterized\" version, in which both the dependence on the numerator and denominator parameters is modelled. For the single parameterized version, use `method='rascal'`, `method='alice'`, and so on. For the double parameterized version, use `method='rascal2'`, `method='alice2'`, etc. Note that for the doubly parameterized estimators you have to provide `theta1_filename`, and in the case of RASCAL and ALICES also `t_xz1_filename`." + "To train this model we will minimize the ALICES loss function described in [\"Likelihood-free inference with an improved cross-entropy estimator\"](https://arxiv.org/abs/1808.00973). Many alternatives, including RASCAL, are described in [\"Constraining Effective Field Theories With Machine Learning\"](https://arxiv.org/abs/1805.00013) and [\"A Guide to Constraining Effective Field Theories With Machine Learning\"](https://arxiv.org/abs/1805.00020). There is also SCANDAL introduced in [\"Mining gold from implicit models to improve likelihood-free inference\"](https://arxiv.org/abs/1805.12244)." ] }, { "cell_type": "code", "execution_count": 25, - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stderr", @@ -1016,21 +1018,18 @@ } ], "source": [ - "forge.train(\n", + "estimator.train(\n", " method='alices',\n", - " theta0_filename='data/samples/theta0_train.npy',\n", - " x_filename='data/samples/x_train.npy',\n", - " y_filename='data/samples/y_train.npy',\n", - " r_xz_filename='data/samples/r_xz_train.npy',\n", - " t_xz0_filename='data/samples/t_xz_train.npy',\n", - " n_hidden=(20,20),\n", - " alpha=10.,\n", + " theta='data/samples/theta0_train.npy',\n", + " x='data/samples/x_train.npy',\n", + " y='data/samples/y_train.npy',\n", + " r_xz='data/samples/r_xz_train.npy',\n", + " t_xz='data/samples/t_xz_train.npy',\n", + " alpha=1.,\n", " n_epochs=20,\n", - " validation_split=0.3,\n", - " batch_size=256\n", ")\n", "\n", - "forge.save('models/alices')" + "estimator.save('models/alices')" ] }, { @@ -1044,12 +1043,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "`forge.evaluate(theta,x)` estimated the log likelihood ratio and the score for all combination between the given phase-space points `x` and parameters `theta`. That is, if given 100 events `x` and a grid of 25 `theta` points, it will return 25\\*100 estimates for the log likelihood and 25\\*100 estimates for the score, both indexed by `[i_theta,i_x]`." + "`estimator.evaluate_log_likelihood_ratio(theta,x)` estimated the log likelihood ratio and the score for all combination between the given phase-space points `x` and parameters `theta`. That is, if given 100 events `x` and a grid of 25 `theta` points, it will return 25\\*100 estimates for the log likelihood ratio and 25\\*100 estimates for the score, both indexed by `[i_theta,i_x]`." ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -1064,14 +1063,29 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "Can't find estimator type information in file. Maybe this file was created with an incompatible MadMiner version < v0.3.0?", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'models/alices'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m log_r_hat, _ = estimator.evaluate_log_likelihood_ratio(\n\u001b[1;32m 4\u001b[0m \u001b[0mtheta\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'data/samples/theta_grid.npy'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'data/samples/x_test.npy'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Users/johannbrehmer/work/projects/madminer/madminer/madminer/ml.py\u001b[0m in \u001b[0;36mload\u001b[0;34m(self, filename)\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"_settings.json\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"r\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0msettings\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 153\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_unwrap_settings\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msettings\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 154\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_create_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 155\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Users/johannbrehmer/work/projects/madminer/madminer/madminer/ml.py\u001b[0m in \u001b[0;36m_unwrap_settings\u001b[0;34m(self, settings)\u001b[0m\n\u001b[1;32m 586\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 587\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_unwrap_settings\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msettings\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 588\u001b[0;31m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mParameterizedRatioEstimator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_unwrap_settings\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msettings\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 589\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 590\u001b[0m \u001b[0mestimator_type\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msettings\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"estimator_type\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Users/johannbrehmer/work/projects/madminer/madminer/madminer/ml.py\u001b[0m in \u001b[0;36m_unwrap_settings\u001b[0;34m(self, settings)\u001b[0m\n\u001b[1;32m 203\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 204\u001b[0m raise RuntimeError(\n\u001b[0;32m--> 205\u001b[0;31m \u001b[0;34m\"Can't find estimator type information in file. Maybe this file was created with\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 206\u001b[0m \u001b[0;34m\" an incompatible MadMiner version < v0.3.0?\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 207\u001b[0m )\n", + "\u001b[0;31mRuntimeError\u001b[0m: Can't find estimator type information in file. Maybe this file was created with an incompatible MadMiner version < v0.3.0?" + ] + } + ], "source": [ - "forge.load('models/alices')\n", + "estimator.load('models/alices')\n", "\n", - "log_r_hat, _, _ = forge.evaluate(\n", - " theta0_filename='data/samples/theta_grid.npy',\n", + "log_r_hat, _ = estimator.evaluate_log_likelihood_ratio(\n", + " theta='data/samples/theta_grid.npy',\n", " x='data/samples/x_test.npy',\n", " evaluate_score=False\n", ")" @@ -1086,14 +1100,12 @@ }, { "cell_type": "code", - "execution_count": 28, - "metadata": { - "scrolled": true - }, + "execution_count": 14, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1135,8 +1147,376 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Note that in this tutorial our sample size was very small, and the network does not really have a chance to converge to the correct likelihood ratio function. So don't worry if you find a minimum that is not at the right point (the SM, i.e. the origin in this plot). Feel free to dial up the event numbers in the run card as well as the training samples and see what happens then!\n", + "Note that in this tutorial our sample size was very small, and the network might not really have a chance to converge to the correct likelihood ratio function. So don't worry if you find a minimum that is not at the right point (the SM, i.e. the origin in this plot). Feel free to dial up the event numbers in the run card as well as the training samples and see what happens then!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Limits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the end, what we care about are not plots of the log likelihood ratio, but limits on parameters. But at least under some asymptotic assumptions, these are directly related. MadMiner makes it easy to calculate p-values in the asymptotic limit with the `AsymptoticLimits` class in the `madminer.limits`: " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:44 madminer.limits INFO Loading data from data/madminer_example_shuffled.h5\n", + "14:44 madminer.limits INFO Found 2 parameters\n", + "14:44 madminer.limits INFO Found 6 benchmarks, of which 6 physical\n", + "14:44 madminer.limits INFO Found 2 observables: pt_j1, delta_phi_jj\n", + "14:44 madminer.limits INFO Found 6537 events\n", + "14:44 madminer.limits INFO Found morphing setup with 6 components\n" + ] + } + ], + "source": [ + "limits = AsymptoticLimits('data/madminer_example_shuffled.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This class provids two high-level functions:\n", + "- `AsymptoticLimits.observed_limits()` lets us calculate p-values on a parameter grid for some observed events, and\n", + "- `AsymptoticLimits.expected_limits()` lets us calculate expected p-values on a parameter grid based on all data in the MadMiner file.\n", + "\n", + "Note that these limits include both rate and kinematic information (the neural network is used for the kinematic part).\n", "\n", + "Let's try both:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "theta_min, theta_max = -20., 20.\n", + "resolution = 25" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Expected limits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, with `mode=\"rate\"`, we can calculate expected limits based only on rate information:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:44 madminer.limits INFO Calculating rate log likelihood\n", + "14:44 madminer.limits INFO Calculating p-values\n" + ] + } + ], + "source": [ + "_, p_values_expected_xsec, best_fit_expected_xsec = limits.expected_limits(\n", + " theta_true=[0.,0.],\n", + " theta_ranges=[(theta_min, theta_max), (theta_min, theta_max)],\n", + " mode=\"rate\",\n", + " resolution=resolution,\n", + " luminosity=300000.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`mode=\"histo\"` calculates limits based on histograms. For now, there is not a lot of freedom in this step, the histogram binning is determined automatically." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:44 madminer.limits INFO Setting up standard summary statistics\n", + "14:44 madminer.limits INFO Creating histogram with 20 bins for the summary statistics\n", + "14:44 madminer.limits INFO Building histogram with %s bins per parameter and %s bins per observable\n", + "14:44 madminer.sampling INFO Loading data from data/madminer_example_shuffled.h5\n", + "14:44 madminer.sampling INFO Found 2 parameters\n", + "14:44 madminer.sampling INFO Did not find nuisance parameters\n", + "14:44 madminer.sampling INFO Found 6 benchmarks, of which 6 physical\n", + "14:44 madminer.sampling INFO Found 2 observables\n", + "14:44 madminer.sampling INFO Found 6537 events\n", + "14:44 madminer.sampling INFO Found morphing setup with 6 components\n", + "14:44 madminer.sampling INFO Extracting plain training sample. Sampling according to ('thetas', [array([-20., -20.]), array([-18.33333333, -20. ]), array([-16.66666667, -20. ]), array([-15., -20.]), array([-13.33333333, -20. ]), array([-11.66666667, -20. ]), array([-10., -20.]), array([ -8.33333333, -20. ]), array([ -6.66666667, -20. ]), array([ -5., -20.]), array([ -3.33333333, -20. ]), array([ -1.66666667, -20. ]), array([ 0., -20.]), array([ 1.66666667, -20. ]), array([ 3.33333333, -20. ]), array([ 5., -20.]), array([ 6.66666667, -20. ]), array([ 8.33333333, -20. ]), array([ 10., -20.]), array([ 11.66666667, -20. ]), array([ 13.33333333, -20. ]), array([ 15., -20.]), array([ 16.66666667, -20. ]), array([ 18.33333333, -20. ]), array([ 20., -20.]), array([-20. , -18.33333333]), array([-18.33333333, -18.33333333]), array([-16.66666667, -18.33333333]), array([-15. , -18.33333333]), array([-13.33333333, -18.33333333]), array([-11.66666667, -18.33333333]), array([-10. , -18.33333333]), array([ -8.33333333, -18.33333333]), array([ -6.66666667, -18.33333333]), array([ -5. , -18.33333333]), array([ -3.33333333, -18.33333333]), array([ -1.66666667, -18.33333333]), array([ 0. , -18.33333333]), array([ 1.66666667, -18.33333333]), array([ 3.33333333, -18.33333333]), array([ 5. , -18.33333333]), array([ 6.66666667, -18.33333333]), array([ 8.33333333, -18.33333333]), array([ 10. , -18.33333333]), array([ 11.66666667, -18.33333333]), array([ 13.33333333, -18.33333333]), array([ 15. , -18.33333333]), array([ 16.66666667, -18.33333333]), array([ 18.33333333, -18.33333333]), array([ 20. , -18.33333333]), array([-20. , -16.66666667]), array([-18.33333333, -16.66666667]), array([-16.66666667, -16.66666667]), array([-15. , -16.66666667]), array([-13.33333333, -16.66666667]), array([-11.66666667, -16.66666667]), array([-10. , -16.66666667]), array([ -8.33333333, -16.66666667]), array([ -6.66666667, -16.66666667]), array([ -5. , -16.66666667]), array([ -3.33333333, -16.66666667]), array([ -1.66666667, -16.66666667]), array([ 0. , -16.66666667]), array([ 1.66666667, -16.66666667]), array([ 3.33333333, -16.66666667]), array([ 5. , -16.66666667]), array([ 6.66666667, -16.66666667]), array([ 8.33333333, -16.66666667]), array([ 10. , -16.66666667]), array([ 11.66666667, -16.66666667]), array([ 13.33333333, -16.66666667]), array([ 15. , -16.66666667]), array([ 16.66666667, -16.66666667]), array([ 18.33333333, -16.66666667]), array([ 20. , -16.66666667]), array([-20., -15.]), array([-18.33333333, -15. ]), array([-16.66666667, -15. ]), array([-15., -15.]), array([-13.33333333, -15. ]), array([-11.66666667, -15. ]), array([-10., -15.]), array([ -8.33333333, -15. ]), array([ -6.66666667, -15. ]), array([ -5., -15.]), array([ -3.33333333, -15. ]), array([ -1.66666667, -15. ]), array([ 0., -15.]), array([ 1.66666667, -15. ]), array([ 3.33333333, -15. ]), array([ 5., -15.]), array([ 6.66666667, -15. ]), array([ 8.33333333, -15. ]), array([ 10., -15.]), array([ 11.66666667, -15. ]), array([ 13.33333333, -15. ]), array([ 15., -15.]), array([ 16.66666667, -15. ]), array([ 18.33333333, -15. ]), array([ 20., -15.]), array([-20. , -13.33333333]), array([-18.33333333, -13.33333333]), array([-16.66666667, -13.33333333]), array([-15. , -13.33333333]), array([-13.33333333, -13.33333333]), array([-11.66666667, -13.33333333]), array([-10. , -13.33333333]), array([ -8.33333333, -13.33333333]), array([ -6.66666667, -13.33333333]), array([ -5. , -13.33333333]), array([ -3.33333333, -13.33333333]), array([ -1.66666667, -13.33333333]), array([ 0. , -13.33333333]), array([ 1.66666667, -13.33333333]), array([ 3.33333333, -13.33333333]), array([ 5. , -13.33333333]), array([ 6.66666667, -13.33333333]), array([ 8.33333333, -13.33333333]), array([ 10. , -13.33333333]), array([ 11.66666667, -13.33333333]), array([ 13.33333333, -13.33333333]), array([ 15. , -13.33333333]), array([ 16.66666667, -13.33333333]), array([ 18.33333333, -13.33333333]), array([ 20. , -13.33333333]), array([-20. , -11.66666667]), array([-18.33333333, -11.66666667]), array([-16.66666667, -11.66666667]), array([-15. , -11.66666667]), array([-13.33333333, -11.66666667]), array([-11.66666667, -11.66666667]), array([-10. , -11.66666667]), array([ -8.33333333, -11.66666667]), array([ -6.66666667, -11.66666667]), array([ -5. , -11.66666667]), array([ -3.33333333, -11.66666667]), array([ -1.66666667, -11.66666667]), array([ 0. , -11.66666667]), array([ 1.66666667, -11.66666667]), array([ 3.33333333, -11.66666667]), array([ 5. , -11.66666667]), array([ 6.66666667, -11.66666667]), array([ 8.33333333, -11.66666667]), array([ 10. , -11.66666667]), array([ 11.66666667, -11.66666667]), array([ 13.33333333, -11.66666667]), array([ 15. , -11.66666667]), array([ 16.66666667, -11.66666667]), array([ 18.33333333, -11.66666667]), array([ 20. , -11.66666667]), array([-20., -10.]), array([-18.33333333, -10. ]), array([-16.66666667, -10. ]), array([-15., -10.]), array([-13.33333333, -10. ]), array([-11.66666667, -10. ]), array([-10., -10.]), array([ -8.33333333, -10. ]), array([ -6.66666667, -10. ]), array([ -5., -10.]), array([ -3.33333333, -10. ]), array([ -1.66666667, -10. ]), array([ 0., -10.]), array([ 1.66666667, -10. ]), array([ 3.33333333, -10. ]), array([ 5., -10.]), array([ 6.66666667, -10. ]), array([ 8.33333333, -10. ]), array([ 10., -10.]), array([ 11.66666667, -10. ]), array([ 13.33333333, -10. ]), array([ 15., -10.]), array([ 16.66666667, -10. ]), array([ 18.33333333, -10. ]), array([ 20., -10.]), array([-20. , -8.33333333]), array([-18.33333333, -8.33333333]), array([-16.66666667, -8.33333333]), array([-15. , -8.33333333]), array([-13.33333333, -8.33333333]), array([-11.66666667, -8.33333333]), array([-10. , -8.33333333]), array([-8.33333333, -8.33333333]), array([-6.66666667, -8.33333333]), array([-5. , -8.33333333]), array([-3.33333333, -8.33333333]), array([-1.66666667, -8.33333333]), array([ 0. , -8.33333333]), array([ 1.66666667, -8.33333333]), array([ 3.33333333, -8.33333333]), array([ 5. , -8.33333333]), array([ 6.66666667, -8.33333333]), array([ 8.33333333, -8.33333333]), array([10. , -8.33333333]), array([11.66666667, -8.33333333]), array([13.33333333, -8.33333333]), array([15. , -8.33333333]), array([16.66666667, -8.33333333]), array([18.33333333, -8.33333333]), array([20. , -8.33333333]), array([-20. , -6.66666667]), array([-18.33333333, -6.66666667]), array([-16.66666667, -6.66666667]), array([-15. , -6.66666667]), array([-13.33333333, -6.66666667]), array([-11.66666667, -6.66666667]), array([-10. , -6.66666667]), array([-8.33333333, -6.66666667]), array([-6.66666667, -6.66666667]), array([-5. , -6.66666667]), array([-3.33333333, -6.66666667]), array([-1.66666667, -6.66666667]), array([ 0. , -6.66666667]), array([ 1.66666667, -6.66666667]), array([ 3.33333333, -6.66666667]), array([ 5. , -6.66666667]), array([ 6.66666667, -6.66666667]), array([ 8.33333333, -6.66666667]), array([10. , -6.66666667]), array([11.66666667, -6.66666667]), array([13.33333333, -6.66666667]), array([15. , -6.66666667]), array([16.66666667, -6.66666667]), array([18.33333333, -6.66666667]), array([20. , -6.66666667]), array([-20., -5.]), array([-18.33333333, -5. ]), array([-16.66666667, -5. ]), array([-15., -5.]), array([-13.33333333, -5. ]), array([-11.66666667, -5. ]), array([-10., -5.]), array([-8.33333333, -5. ]), array([-6.66666667, -5. ]), array([-5., -5.]), array([-3.33333333, -5. ]), array([-1.66666667, -5. ]), array([ 0., -5.]), array([ 1.66666667, -5. ]), array([ 3.33333333, -5. ]), array([ 5., -5.]), array([ 6.66666667, -5. ]), array([ 8.33333333, -5. ]), array([10., -5.]), array([11.66666667, -5. ]), array([13.33333333, -5. ]), array([15., -5.]), array([16.66666667, -5. ]), array([18.33333333, -5. ]), array([20., -5.]), array([-20. , -3.33333333]), array([-18.33333333, -3.33333333]), array([-16.66666667, -3.33333333]), array([-15. , -3.33333333]), array([-13.33333333, -3.33333333]), array([-11.66666667, -3.33333333]), array([-10. , -3.33333333]), array([-8.33333333, -3.33333333]), array([-6.66666667, -3.33333333]), array([-5. , -3.33333333]), array([-3.33333333, -3.33333333]), array([-1.66666667, -3.33333333]), array([ 0. , -3.33333333]), array([ 1.66666667, -3.33333333]), array([ 3.33333333, -3.33333333]), array([ 5. , -3.33333333]), array([ 6.66666667, -3.33333333]), array([ 8.33333333, -3.33333333]), array([10. , -3.33333333]), array([11.66666667, -3.33333333]), array([13.33333333, -3.33333333]), array([15. , -3.33333333]), array([16.66666667, -3.33333333]), array([18.33333333, -3.33333333]), array([20. , -3.33333333]), array([-20. , -1.66666667]), array([-18.33333333, -1.66666667]), array([-16.66666667, -1.66666667]), array([-15. , -1.66666667]), array([-13.33333333, -1.66666667]), array([-11.66666667, -1.66666667]), array([-10. , -1.66666667]), array([-8.33333333, -1.66666667]), array([-6.66666667, -1.66666667]), array([-5. , -1.66666667]), array([-3.33333333, -1.66666667]), array([-1.66666667, -1.66666667]), array([ 0. , -1.66666667]), array([ 1.66666667, -1.66666667]), array([ 3.33333333, -1.66666667]), array([ 5. , -1.66666667]), array([ 6.66666667, -1.66666667]), array([ 8.33333333, -1.66666667]), array([10. , -1.66666667]), array([11.66666667, -1.66666667]), array([13.33333333, -1.66666667]), array([15. , -1.66666667]), array([16.66666667, -1.66666667]), array([18.33333333, -1.66666667]), array([20. , -1.66666667]), array([-20., 0.]), array([-18.33333333, 0. ]), array([-16.66666667, 0. ]), array([-15., 0.]), array([-13.33333333, 0. ]), array([-11.66666667, 0. ]), array([-10., 0.]), array([-8.33333333, 0. ]), array([-6.66666667, 0. ]), array([-5., 0.]), array([-3.33333333, 0. ]), array([-1.66666667, 0. ]), array([0., 0.]), array([1.66666667, 0. ]), array([3.33333333, 0. ]), array([5., 0.]), array([6.66666667, 0. ]), array([8.33333333, 0. ]), array([10., 0.]), array([11.66666667, 0. ]), array([13.33333333, 0. ]), array([15., 0.]), array([16.66666667, 0. ]), array([18.33333333, 0. ]), array([20., 0.]), array([-20. , 1.66666667]), array([-18.33333333, 1.66666667]), array([-16.66666667, 1.66666667]), array([-15. , 1.66666667]), array([-13.33333333, 1.66666667]), array([-11.66666667, 1.66666667]), array([-10. , 1.66666667]), array([-8.33333333, 1.66666667]), array([-6.66666667, 1.66666667]), array([-5. , 1.66666667]), array([-3.33333333, 1.66666667]), array([-1.66666667, 1.66666667]), array([0. , 1.66666667]), array([1.66666667, 1.66666667]), array([3.33333333, 1.66666667]), array([5. , 1.66666667]), array([6.66666667, 1.66666667]), array([8.33333333, 1.66666667]), array([10. , 1.66666667]), array([11.66666667, 1.66666667]), array([13.33333333, 1.66666667]), array([15. , 1.66666667]), array([16.66666667, 1.66666667]), array([18.33333333, 1.66666667]), array([20. , 1.66666667]), array([-20. , 3.33333333]), array([-18.33333333, 3.33333333]), array([-16.66666667, 3.33333333]), array([-15. , 3.33333333]), array([-13.33333333, 3.33333333]), array([-11.66666667, 3.33333333]), array([-10. , 3.33333333]), array([-8.33333333, 3.33333333]), array([-6.66666667, 3.33333333]), array([-5. , 3.33333333]), array([-3.33333333, 3.33333333]), array([-1.66666667, 3.33333333]), array([0. , 3.33333333]), array([1.66666667, 3.33333333]), array([3.33333333, 3.33333333]), array([5. , 3.33333333]), array([6.66666667, 3.33333333]), array([8.33333333, 3.33333333]), array([10. , 3.33333333]), array([11.66666667, 3.33333333]), array([13.33333333, 3.33333333]), array([15. , 3.33333333]), array([16.66666667, 3.33333333]), array([18.33333333, 3.33333333]), array([20. , 3.33333333]), array([-20., 5.]), array([-18.33333333, 5. ]), array([-16.66666667, 5. ]), array([-15., 5.]), array([-13.33333333, 5. ]), array([-11.66666667, 5. ]), array([-10., 5.]), array([-8.33333333, 5. ]), array([-6.66666667, 5. ]), array([-5., 5.]), array([-3.33333333, 5. ]), array([-1.66666667, 5. ]), array([0., 5.]), array([1.66666667, 5. ]), array([3.33333333, 5. ]), array([5., 5.]), array([6.66666667, 5. ]), array([8.33333333, 5. ]), array([10., 5.]), array([11.66666667, 5. ]), array([13.33333333, 5. ]), array([15., 5.]), array([16.66666667, 5. ]), array([18.33333333, 5. ]), array([20., 5.]), array([-20. , 6.66666667]), array([-18.33333333, 6.66666667]), array([-16.66666667, 6.66666667]), array([-15. , 6.66666667]), array([-13.33333333, 6.66666667]), array([-11.66666667, 6.66666667]), array([-10. , 6.66666667]), array([-8.33333333, 6.66666667]), array([-6.66666667, 6.66666667]), array([-5. , 6.66666667]), array([-3.33333333, 6.66666667]), array([-1.66666667, 6.66666667]), array([0. , 6.66666667]), array([1.66666667, 6.66666667]), array([3.33333333, 6.66666667]), array([5. , 6.66666667]), array([6.66666667, 6.66666667]), array([8.33333333, 6.66666667]), array([10. , 6.66666667]), array([11.66666667, 6.66666667]), array([13.33333333, 6.66666667]), array([15. , 6.66666667]), array([16.66666667, 6.66666667]), array([18.33333333, 6.66666667]), array([20. , 6.66666667]), array([-20. , 8.33333333]), array([-18.33333333, 8.33333333]), array([-16.66666667, 8.33333333]), array([-15. , 8.33333333]), array([-13.33333333, 8.33333333]), array([-11.66666667, 8.33333333]), array([-10. , 8.33333333]), array([-8.33333333, 8.33333333]), array([-6.66666667, 8.33333333]), array([-5. , 8.33333333]), array([-3.33333333, 8.33333333]), array([-1.66666667, 8.33333333]), array([0. , 8.33333333]), array([1.66666667, 8.33333333]), array([3.33333333, 8.33333333]), array([5. , 8.33333333]), array([6.66666667, 8.33333333]), array([8.33333333, 8.33333333]), array([10. , 8.33333333]), array([11.66666667, 8.33333333]), array([13.33333333, 8.33333333]), array([15. , 8.33333333]), array([16.66666667, 8.33333333]), array([18.33333333, 8.33333333]), array([20. , 8.33333333]), array([-20., 10.]), array([-18.33333333, 10. ]), array([-16.66666667, 10. ]), array([-15., 10.]), array([-13.33333333, 10. ]), array([-11.66666667, 10. ]), array([-10., 10.]), array([-8.33333333, 10. ]), array([-6.66666667, 10. ]), array([-5., 10.]), array([-3.33333333, 10. ]), array([-1.66666667, 10. ]), array([ 0., 10.]), array([ 1.66666667, 10. ]), array([ 3.33333333, 10. ]), array([ 5., 10.]), array([ 6.66666667, 10. ]), array([ 8.33333333, 10. ]), array([10., 10.]), array([11.66666667, 10. ]), array([13.33333333, 10. ]), array([15., 10.]), array([16.66666667, 10. ]), array([18.33333333, 10. ]), array([20., 10.]), array([-20. , 11.66666667]), array([-18.33333333, 11.66666667]), array([-16.66666667, 11.66666667]), array([-15. , 11.66666667]), array([-13.33333333, 11.66666667]), array([-11.66666667, 11.66666667]), array([-10. , 11.66666667]), array([-8.33333333, 11.66666667]), array([-6.66666667, 11.66666667]), array([-5. , 11.66666667]), array([-3.33333333, 11.66666667]), array([-1.66666667, 11.66666667]), array([ 0. , 11.66666667]), array([ 1.66666667, 11.66666667]), array([ 3.33333333, 11.66666667]), array([ 5. , 11.66666667]), array([ 6.66666667, 11.66666667]), array([ 8.33333333, 11.66666667]), array([10. , 11.66666667]), array([11.66666667, 11.66666667]), array([13.33333333, 11.66666667]), array([15. , 11.66666667]), array([16.66666667, 11.66666667]), array([18.33333333, 11.66666667]), array([20. , 11.66666667]), array([-20. , 13.33333333]), array([-18.33333333, 13.33333333]), array([-16.66666667, 13.33333333]), array([-15. , 13.33333333]), array([-13.33333333, 13.33333333]), array([-11.66666667, 13.33333333]), array([-10. , 13.33333333]), array([-8.33333333, 13.33333333]), array([-6.66666667, 13.33333333]), array([-5. , 13.33333333]), array([-3.33333333, 13.33333333]), array([-1.66666667, 13.33333333]), array([ 0. , 13.33333333]), array([ 1.66666667, 13.33333333]), array([ 3.33333333, 13.33333333]), array([ 5. , 13.33333333]), array([ 6.66666667, 13.33333333]), array([ 8.33333333, 13.33333333]), array([10. , 13.33333333]), array([11.66666667, 13.33333333]), array([13.33333333, 13.33333333]), array([15. , 13.33333333]), array([16.66666667, 13.33333333]), array([18.33333333, 13.33333333]), array([20. , 13.33333333]), array([-20., 15.]), array([-18.33333333, 15. ]), array([-16.66666667, 15. ]), array([-15., 15.]), array([-13.33333333, 15. ]), array([-11.66666667, 15. ]), array([-10., 15.]), array([-8.33333333, 15. ]), array([-6.66666667, 15. ]), array([-5., 15.]), array([-3.33333333, 15. ]), array([-1.66666667, 15. ]), array([ 0., 15.]), array([ 1.66666667, 15. ]), array([ 3.33333333, 15. ]), array([ 5., 15.]), array([ 6.66666667, 15. ]), array([ 8.33333333, 15. ]), array([10., 15.]), array([11.66666667, 15. ]), array([13.33333333, 15. ]), array([15., 15.]), array([16.66666667, 15. ]), array([18.33333333, 15. ]), array([20., 15.]), array([-20. , 16.66666667]), array([-18.33333333, 16.66666667]), array([-16.66666667, 16.66666667]), array([-15. , 16.66666667]), array([-13.33333333, 16.66666667]), array([-11.66666667, 16.66666667]), array([-10. , 16.66666667]), array([-8.33333333, 16.66666667]), array([-6.66666667, 16.66666667]), array([-5. , 16.66666667]), array([-3.33333333, 16.66666667]), array([-1.66666667, 16.66666667]), array([ 0. , 16.66666667]), array([ 1.66666667, 16.66666667]), array([ 3.33333333, 16.66666667]), array([ 5. , 16.66666667]), array([ 6.66666667, 16.66666667]), array([ 8.33333333, 16.66666667]), array([10. , 16.66666667]), array([11.66666667, 16.66666667]), array([13.33333333, 16.66666667]), array([15. , 16.66666667]), array([16.66666667, 16.66666667]), array([18.33333333, 16.66666667]), array([20. , 16.66666667]), array([-20. , 18.33333333]), array([-18.33333333, 18.33333333]), array([-16.66666667, 18.33333333]), array([-15. , 18.33333333]), array([-13.33333333, 18.33333333]), array([-11.66666667, 18.33333333]), array([-10. , 18.33333333]), array([-8.33333333, 18.33333333]), array([-6.66666667, 18.33333333]), array([-5. , 18.33333333]), array([-3.33333333, 18.33333333]), array([-1.66666667, 18.33333333]), array([ 0. , 18.33333333]), array([ 1.66666667, 18.33333333]), array([ 3.33333333, 18.33333333]), array([ 5. , 18.33333333]), array([ 6.66666667, 18.33333333]), array([ 8.33333333, 18.33333333]), array([10. , 18.33333333]), array([11.66666667, 18.33333333]), array([13.33333333, 18.33333333]), array([15. , 18.33333333]), array([16.66666667, 18.33333333]), array([18.33333333, 18.33333333]), array([20. , 18.33333333]), array([-20., 20.]), array([-18.33333333, 20. ]), array([-16.66666667, 20. ]), array([-15., 20.]), array([-13.33333333, 20. ]), array([-11.66666667, 20. ]), array([-10., 20.]), array([-8.33333333, 20. ]), array([-6.66666667, 20. ]), array([-5., 20.]), array([-3.33333333, 20. ]), array([-1.66666667, 20. ]), array([ 0., 20.]), array([ 1.66666667, 20. ]), array([ 3.33333333, 20. ]), array([ 5., 20.]), array([ 6.66666667, 20. ]), array([ 8.33333333, 20. ]), array([10., 20.]), array([11.66666667, 20. ]), array([13.33333333, 20. ]), array([15., 20.]), array([16.66666667, 20. ]), array([18.33333333, 20. ]), array([20., 20.])])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:44 madminer.sampling WARNING Large statistical uncertainty on the total cross section for theta = [-20. -20.]: (0.005813 +/- 0.001110) pb. Skipping these warnings in the future...\n", + "14:44 madminer.sampling WARNING For this value of theta, 1 / 5230 events have negative weight and will be ignored\n", + "14:44 madminer.sampling WARNING For this value of theta, 1 / 5230 events have negative weight and will be ignored\n", + "14:44 madminer.sampling WARNING For this value of theta, 1 / 5230 events have negative weight and will be ignored\n", + "14:44 madminer.sampling WARNING Skipping warnings about negative weights in the future...\n", + "14:44 madminer.sampling INFO Effective number of samples: mean 23.864853750376064, with individual thetas ranging from 6.466907370230287 to 5230.000000000667\n", + "14:44 madminer.limits INFO Calculating kinematic log likelihood with histograms\n", + "/Users/johannbrehmer/work/projects/madminer/madminer/madminer/utils/histo.py:200: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n", + " log_p += np.log(histo[histo_indices])\n", + "14:44 madminer.limits INFO Calculating p-values\n" + ] + } + ], + "source": [ + "_, p_values_expected_histo, best_fit_expected_histo = limits.expected_limits(\n", + " theta_true=[0.,0.],\n", + " theta_ranges=[(theta_min, theta_max), (theta_min, theta_max)],\n", + " mode=\"histo\",\n", + " hist_vars=[\"pt_j1\"],\n", + " include_xsec=False,\n", + " resolution=resolution,\n", + " luminosity=300000.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally and perhaps most importantly, `mode=\"ml\"` allows us to calculate limits based on any `ParamterizedRatioEstimator` instance like the ALICES estimator trained above:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:44 madminer.limits INFO Loading kinematic likelihood ratio estimator\n", + "14:44 madminer.limits INFO Calculating kinematic log likelihood ratio with estimator\n", + "14:45 madminer.limits INFO Calculating p-values\n" + ] + } + ], + "source": [ + "theta_grid, p_values_expected_ml, best_fit_expected_ml = limits.expected_limits(\n", + " theta_true=[0.,0.],\n", + " theta_ranges=[(theta_min, theta_max), (theta_min, theta_max)],\n", + " mode=\"ml\",\n", + " model_file='models/alices',\n", + " include_xsec=False,\n", + " resolution=resolution,\n", + " luminosity=300000.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Observed limits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Observed limits take as input actual data, which we here generate on the fly:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:45 madminer.sampling INFO Loading data from data/madminer_example_shuffled.h5\n", + "14:45 madminer.sampling INFO Found 2 parameters\n", + "14:45 madminer.sampling INFO Did not find nuisance parameters\n", + "14:45 madminer.sampling INFO Found 6 benchmarks, of which 6 physical\n", + "14:45 madminer.sampling INFO Found 2 observables\n", + "14:45 madminer.sampling INFO Found 6537 events\n", + "14:45 madminer.sampling INFO Found morphing setup with 6 components\n", + "14:45 madminer.sampling INFO Extracting evaluation sample. Sampling according to ('theta', array([0., 0.]))\n", + "14:45 madminer.sampling INFO Effective number of samples: 1305.9999999999793\n" + ] + } + ], + "source": [ + "sampler = SampleAugmenter('data/madminer_example_shuffled.h5')\n", + "x_observed, _ = sampler.extract_samples_test(\n", + " theta=sampling.morphing_point([0.,0.]),\n", + " n_samples=5,\n", + " folder=None,\n", + " filename=None\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:45 madminer.limits INFO Loading kinematic likelihood ratio estimator\n", + "14:45 madminer.limits INFO Calculating kinematic log likelihood ratio with estimator\n", + "14:45 madminer.limits INFO Calculating rate log likelihood\n", + "14:45 madminer.limits INFO Calculating p-values\n" + ] + } + ], + "source": [ + "_, p_values_observed, best_fit_observed = limits.observed_limits(\n", + " x_observed=x_observed,\n", + " theta_ranges=[(theta_min, theta_max), (theta_min, theta_max)],\n", + " mode=\"ml\",\n", + " model_file='models/alices',\n", + " include_xsec=True,\n", + " resolution=resolution,\n", + " luminosity=300000.0,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's plot the results:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "bin_size = (theta_max - theta_min)/(resolution - 1)\n", + "edges = np.linspace(theta_min - bin_size/2, theta_max + bin_size/2, resolution + 1)\n", + "centers = np.linspace(theta_min, theta_max, resolution)\n", + "\n", + "fig = plt.figure(figsize=(6,5))\n", + "ax = plt.gca()\n", + "\n", + "cmin, cmax = 1.e-3, 1.\n", + " \n", + "pcm = ax.pcolormesh(\n", + " edges, edges, p_values_expected_ml.reshape((resolution, resolution)),\n", + " norm=matplotlib.colors.LogNorm(vmin=cmin, vmax=cmax),\n", + " cmap='Greys_r'\n", + ")\n", + "cbar = fig.colorbar(pcm, ax=ax, extend='both')\n", + "\n", + "plt.contour(\n", + " centers, centers, p_values_expected_xsec.reshape((resolution, resolution)),\n", + " levels=[0.05],\n", + " linestyles='-', colors='darkgreen'\n", + ")\n", + "plt.contour(\n", + " centers, centers, p_values_expected_ml.reshape((resolution, resolution)),\n", + " levels=[0.05],\n", + " linestyles='-', colors='#CC002E'\n", + ")\n", + "plt.contour(\n", + " centers, centers, p_values_expected_histo.reshape((resolution, resolution)),\n", + " levels=[0.05],\n", + " linestyles='-', colors='C1'\n", + ")\n", + "plt.contour(\n", + " centers, centers, p_values_observed.reshape((resolution, resolution)),\n", + " levels=[0.05],\n", + " linestyles='--', colors='black'\n", + ")\n", + "\n", + "plt.scatter(\n", + " theta_grid[best_fit_expected_xsec][0], theta_grid[best_fit_expected_xsec][1],\n", + " s=80., color='darkgreen', marker='*',\n", + " label=\"xsec\"\n", + ")\n", + "plt.scatter(\n", + " theta_grid[best_fit_expected_ml][0], theta_grid[best_fit_expected_ml][1],\n", + " s=80., color='#CC002E', marker='*',\n", + " label=\"ALICES\"\n", + ")\n", + "plt.scatter(\n", + " theta_grid[best_fit_expected_histo][0], theta_grid[best_fit_expected_histo][1],\n", + " s=80., color='C1', marker='*',\n", + " label=\"Histo\"\n", + ")\n", + "plt.scatter(\n", + " theta_grid[best_fit_observed][0], theta_grid[best_fit_observed][1],\n", + " s=80., color='black', marker='*',\n", + " label=\"Observed\"\n", + ")\n", + "\n", + "plt.legend()\n", + "\n", + "plt.xlabel(r'$\\theta_0$')\n", + "plt.ylabel(r'$\\theta_1$')\n", + "cbar.set_label('Expected p-value (ALICES)')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ "That's it for now. Please have a look at the documentation for a detailed description of all classes and functions. And if you're curious about SALLY, Fisher information matrices, and ensemble methods, please look at the second part of the tutorial!" ] }, diff --git a/examples/tutorial_delphes/2_score_information_ensemble.ipynb b/examples/tutorial_delphes/2_score_information_ensemble.ipynb index f4b827de0..3b671b5a5 100755 --- a/examples/tutorial_delphes/2_score_information_ensemble.ipynb +++ b/examples/tutorial_delphes/2_score_information_ensemble.ipynb @@ -47,8 +47,9 @@ "from matplotlib import pyplot as plt\n", "%matplotlib inline\n", "\n", - "from madminer.sampling import SampleAugmenter, constant_benchmark_theta\n", - "from madminer.ml import MLForge, EnsembleForge\n", + "from madminer import sampling\n", + "from madminer.sampling import SampleAugmenter\n", + "from madminer.ml import ScoreEstimator, Ensemble\n", "from madminer.fisherinformation import FisherInformation\n", "from madminer.plotting import plot_fisher_information_contours_2d\n" ] @@ -116,25 +117,25 @@ "name": "stderr", "output_type": "stream", "text": [ - "09:28 madminer.sampling INFO Loading data from data/madminer_example_shuffled.h5\n", - "09:28 madminer.sampling INFO Found 2 parameters\n", - "09:28 madminer.sampling INFO Did not find nuisance parameters\n", - "09:28 madminer.sampling INFO Found 6 benchmarks, of which 6 physical\n", - "09:28 madminer.sampling INFO Found 2 observables\n", - "09:28 madminer.sampling INFO Found 46134 events\n", - "09:28 madminer.sampling INFO Found morphing setup with 6 components\n" + "15:36 madminer.analysis INFO Loading data from data/madminer_example_shuffled.h5\n", + "15:36 madminer.analysis INFO Found 2 parameters\n", + "15:36 madminer.analysis INFO Did not find nuisance parameters\n", + "15:36 madminer.analysis INFO Found 6 benchmarks, of which 6 physical\n", + "15:36 madminer.analysis INFO Found 2 observables\n", + "15:36 madminer.analysis INFO Found 6537 events\n", + "15:36 madminer.analysis INFO Found morphing setup with 6 components\n" ] } ], "source": [ - "sa = SampleAugmenter('data/madminer_example_shuffled.h5')" + "sampler = SampleAugmenter('data/madminer_example_shuffled.h5')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The relevant `SampleAugmenter` function for local score estimators is `extract_samples_train_local()`. As before, for the argument `theta` you can use the helper functions `constant_benchmark_theta()`, `multiple_benchmark_thetas()`, `constant_morphing_theta()`, `multiple_morphing_thetas()`, and `random_morphing_thetas()`." + "The relevant `SampleAugmenter` function for local score estimators is `extract_samples_train_local()`. As before, for the argument `theta` you can use the helper functions `sampling.benchmark()`, `sampling.benchmarks()`, `sampling.morphing_point()`, `sampling.morphing_points()`, and `sampling.random_morphing_points()`." ] }, { @@ -146,14 +147,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "09:28 madminer.sampling INFO Extracting training sample for local score regression. Sampling and score evaluation according to (u'benchmark', u'sm')\n", - "09:28 madminer.sampling INFO Effective number of samples: 23067.0000000061\n" + "15:36 madminer.sampling INFO Extracting training sample for local score regression. Sampling and score evaluation according to (u'benchmark', u'sm')\n", + "15:36 madminer.sampling INFO Effective number of samples: 5230.0\n" ] } ], "source": [ - "x, theta, t_xz = sa.extract_samples_train_local(\n", - " theta=constant_benchmark_theta('sm'),\n", + "x, theta, t_xz, _ = sampler.sample_train_local(\n", + " theta=sampling.benchmark('sm'),\n", " n_samples=100000,\n", " folder='./data/samples',\n", " filename='train'\n", @@ -173,7 +174,7 @@ "source": [ "It's now time to build a neural network. Only this time, instead of the likelihood ratio itself, we will estimate the gradient of the log likelihood with respect to the theory parameters -- the score. To be precise, the output of the neural network is an estimate of the score at some reference parameter point, for instance the Standard Model. A neural network that estimates this \"local\" score can be used to calculate the Fisher information at that point. The estimated score can also be used as a machine learning version of Optimal Observables, and likelihoods can be estimated based on density estimation in the estimated score space. This method for likelihood ratio estimation is called SALLY, and there is a closely related version called SALLINO. Both are explained in [\"Constraining Effective Field Theories With Machine Learning\"](https://arxiv.org/abs/1805.00013) and [\"A Guide to Constraining Effective Field Theories With Machine Learning\"](https://arxiv.org/abs/1805.00020).\n", "\n", - "Again, the central object for this is the `madminer.ml.MLForge` class:" + "The central object for this is the `madminer.ml.ScoreEstimator` class:" ] }, { @@ -182,7 +183,7 @@ "metadata": {}, "outputs": [], "source": [ - "forge = MLForge()" + "estimator = ScoreEstimator(n_hidden=(20,))" ] }, { @@ -201,65 +202,65 @@ "name": "stderr", "output_type": "stream", "text": [ - "09:28 madminer.ml INFO Starting training\n", - "09:28 madminer.ml INFO Method: sally\n", - "09:28 madminer.ml INFO Training data: x at data/samples/x_train.npy\n", - "09:28 madminer.ml INFO t_xz (theta0) at data/samples/t_xz_train.npy\n", - "09:28 madminer.ml INFO Features: all\n", - "09:28 madminer.ml INFO Method: sally\n", - "09:28 madminer.ml INFO Hidden layers: (100, 100)\n", - "09:28 madminer.ml INFO Activation function: tanh\n", - "09:28 madminer.ml INFO Batch size: 256\n", - "09:28 madminer.ml INFO Trainer: amsgrad\n", - "09:28 madminer.ml INFO Epochs: 20\n", - "09:28 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "09:28 madminer.ml INFO Validation split: 0.3\n", - "09:28 madminer.ml INFO Early stopping: True\n", - "09:28 madminer.ml INFO Scale inputs: True\n", - "09:28 madminer.ml INFO Shuffle labels False\n", - "09:28 madminer.ml INFO Regularization: None\n", - "09:28 madminer.ml INFO Samples: all\n", - "09:28 madminer.ml INFO Loading training data\n", - "09:28 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", - "09:28 madminer.ml INFO Rescaling inputs\n", - "09:28 madminer.ml INFO Creating model for method sally\n", - "09:28 madminer.ml INFO Training model\n", - "09:29 madminer.utils.ml.sc INFO Epoch 02: train loss 0.3547 (mse_score: 0.3547)\n", - "09:29 madminer.utils.ml.sc INFO val. loss 0.3119 (mse_score: 0.3119) (*)\n", - "09:29 madminer.utils.ml.sc INFO Epoch 04: train loss 0.3385 (mse_score: 0.3385)\n", - "09:29 madminer.utils.ml.sc INFO val. loss 0.3049 (mse_score: 0.3049) (*)\n", - "09:29 madminer.utils.ml.sc INFO Epoch 06: train loss 0.3327 (mse_score: 0.3327)\n", - "09:29 madminer.utils.ml.sc INFO val. loss 0.3036 (mse_score: 0.3036) (*)\n", - "09:29 madminer.utils.ml.sc INFO Epoch 08: train loss 0.3303 (mse_score: 0.3303)\n", - "09:29 madminer.utils.ml.sc INFO val. loss 0.3014 (mse_score: 0.3014)\n", - "09:30 madminer.utils.ml.sc INFO Epoch 10: train loss 0.3259 (mse_score: 0.3259)\n", - "09:30 madminer.utils.ml.sc INFO val. loss 0.2969 (mse_score: 0.2969) (*)\n", - "09:30 madminer.utils.ml.sc INFO Epoch 12: train loss 0.3239 (mse_score: 0.3239)\n", - "09:30 madminer.utils.ml.sc INFO val. loss 0.2981 (mse_score: 0.2981)\n", - "09:30 madminer.utils.ml.sc INFO Epoch 14: train loss 0.3229 (mse_score: 0.3229)\n", - "09:30 madminer.utils.ml.sc INFO val. loss 0.2977 (mse_score: 0.2977)\n", - "09:30 madminer.utils.ml.sc INFO Epoch 16: train loss 0.3218 (mse_score: 0.3218)\n", - "09:30 madminer.utils.ml.sc INFO val. loss 0.2952 (mse_score: 0.2952) (*)\n", - "09:31 madminer.utils.ml.sc INFO Epoch 18: train loss 0.3211 (mse_score: 0.3211)\n", - "09:31 madminer.utils.ml.sc INFO val. loss 0.2966 (mse_score: 0.2966)\n", - "09:31 madminer.utils.ml.sc INFO Epoch 20: train loss 0.3204 (mse_score: 0.3204)\n", - "09:31 madminer.utils.ml.sc INFO val. loss 0.2951 (mse_score: 0.2951)\n", - "09:31 madminer.utils.ml.sc INFO Early stopping after epoch 17, with loss 0.29 compared to final loss 0.30\n", - "09:31 madminer.utils.ml.sc INFO Finished training\n" + "15:36 madminer.ml INFO Starting training\n", + "15:36 madminer.ml INFO Batch size: 200\n", + "15:36 madminer.ml INFO Optimizer: amsgrad\n", + "15:36 madminer.ml INFO Epochs: 50\n", + "15:36 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", + "15:36 madminer.ml INFO Validation split: 0.25\n", + "15:36 madminer.ml INFO Early stopping: True\n", + "15:36 madminer.ml INFO Scale inputs: True\n", + "15:36 madminer.ml INFO Shuffle labels False\n", + "15:36 madminer.ml INFO Samples: all\n", + "15:36 madminer.ml INFO Loading training data\n", + "15:36 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", + "15:36 madminer.ml INFO Rescaling inputs\n", + "15:36 madminer.ml INFO Creating model\n", + "15:36 madminer.ml INFO Training model\n", + "15:36 madminer.utils.ml.tr INFO Epoch 3: train loss 0.19037 (mse_score: 0.190)\n", + "15:36 madminer.utils.ml.tr INFO val. loss 0.15904 (mse_score: 0.159)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 6: train loss 0.14389 (mse_score: 0.144)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.12421 (mse_score: 0.124)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 9: train loss 0.12970 (mse_score: 0.130)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.11444 (mse_score: 0.114)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 12: train loss 0.12303 (mse_score: 0.123)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.10981 (mse_score: 0.110)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 15: train loss 0.11926 (mse_score: 0.119)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.10723 (mse_score: 0.107)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 18: train loss 0.11690 (mse_score: 0.117)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.10569 (mse_score: 0.106)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 21: train loss 0.11537 (mse_score: 0.115)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.10467 (mse_score: 0.105)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 24: train loss 0.11426 (mse_score: 0.114)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.10407 (mse_score: 0.104)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 27: train loss 0.11342 (mse_score: 0.113)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.10358 (mse_score: 0.104)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 30: train loss 0.11283 (mse_score: 0.113)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.10306 (mse_score: 0.103)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 33: train loss 0.11231 (mse_score: 0.112)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.10260 (mse_score: 0.103)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 36: train loss 0.11192 (mse_score: 0.112)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.10236 (mse_score: 0.102)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 39: train loss 0.11158 (mse_score: 0.112)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.10215 (mse_score: 0.102)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 42: train loss 0.11129 (mse_score: 0.111)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.10194 (mse_score: 0.102)\n", + "15:39 madminer.utils.ml.tr INFO Epoch 45: train loss 0.11106 (mse_score: 0.111)\n", + "15:39 madminer.utils.ml.tr INFO val. loss 0.10175 (mse_score: 0.102)\n", + "15:39 madminer.utils.ml.tr INFO Epoch 48: train loss 0.11085 (mse_score: 0.111)\n", + "15:39 madminer.utils.ml.tr INFO val. loss 0.10162 (mse_score: 0.102)\n", + "15:39 madminer.utils.ml.tr INFO Early stopping did not improve performance\n" ] } ], "source": [ - "forge.train(\n", + "estimator.train(\n", " method='sally',\n", - " x_filename='data/samples/x_train.npy',\n", - " t_xz0_filename='data/samples/t_xz_train.npy',\n", - " n_epochs=20,\n", - " batch_size=256,\n", - " validation_split=0.3\n", + " x='data/samples/x_train.npy',\n", + " t_xz='data/samples/t_xz_train.npy',\n", ")\n", "\n", - "forge.save('models/sally')" + "estimator.save('models/sally')" ] }, { @@ -282,9 +283,9 @@ "metadata": {}, "outputs": [], "source": [ - "forge.load('models/sally')\n", + "estimator.load('models/sally')\n", "\n", - "t_hat = forge.evaluate(\n", + "t_hat = estimator.evaluate_score(\n", " x='data/samples/x_test.npy'\n", ")" ] @@ -303,7 +304,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -359,13 +360,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "09:31 madminer.fisherinfor INFO Loading data from data/madminer_example_shuffled.h5\n", - "09:31 madminer.fisherinfor INFO Found 2 parameters\n", - "09:31 madminer.fisherinfor WARNING Did not find nuisance parameters!\n", - "09:31 madminer.fisherinfor INFO Found 6 benchmarks, of which 6 physical\n", - "09:31 madminer.fisherinfor INFO Found 2 observables: pt_j1, delta_phi_jj\n", - "09:31 madminer.fisherinfor INFO Found 46134 events\n", - "09:31 madminer.fisherinfor INFO Found morphing setup with 6 components\n" + "15:39 madminer.analysis INFO Loading data from data/madminer_example_shuffled.h5\n", + "15:39 madminer.analysis INFO Found 2 parameters\n", + "15:39 madminer.analysis INFO Did not find nuisance parameters\n", + "15:39 madminer.analysis INFO Found 6 benchmarks, of which 6 physical\n", + "15:39 madminer.analysis INFO Found 2 observables\n", + "15:39 madminer.analysis INFO Found 6537 events\n", + "15:39 madminer.analysis INFO Found morphing setup with 6 components\n" ] } ], @@ -382,17 +383,22 @@ "name": "stderr", "output_type": "stream", "text": [ - "09:31 madminer.fisherinfor INFO Evaluating rate Fisher information\n", - "09:31 madminer.utils.inter WARNING include_nuisance_parameters=False without benchmark_is_nuisance information. Returning all weights.\n" + "15:39 madminer.fisherinfor INFO Evaluating rate Fisher information\n", + "15:39 madminer.utils.inter WARNING include_nuisance_parameters=False without benchmark_is_nuisance information. Returning all weights.\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Kinematic Fisher information after 3000 ifb:\n", - "[[1369.72408453 61.3498349 ]\n", - " [ 61.3498349 419.61370008]]\n" + "ename": "AttributeError", + "evalue": "'NoneType' object has no attribute 'calculate_a'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mtheta\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0.\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mmodel_file\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'models/sally'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mluminosity\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3000000.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m )\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Users/johannbrehmer/work/projects/madminer/madminer/madminer/fisherinformation.pyc\u001b[0m in \u001b[0;36mcalculate_fisher_information_full_detector\u001b[0;34m(self, theta, model_file, unweighted_x_sample_file, luminosity, include_xsec_info, mode, calculate_covariance, batch_size, test_split)\u001b[0m\n\u001b[1;32m 257\u001b[0m \u001b[0mlogger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minfo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Evaluating rate Fisher information\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 258\u001b[0m fisher_info_rate, rate_covariance = self.calculate_fisher_information_rate(\n\u001b[0;32m--> 259\u001b[0;31m \u001b[0mtheta\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtheta\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mluminosity\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mluminosity\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minclude_nuisance_parameters\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minclude_nuisance_parameters\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 260\u001b[0m )\n\u001b[1;32m 261\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Users/johannbrehmer/work/projects/madminer/madminer/madminer/fisherinformation.pyc\u001b[0m in \u001b[0;36mcalculate_fisher_information_rate\u001b[0;34m(self, theta, luminosity, cuts, efficiency_functions, include_nuisance_parameters)\u001b[0m\n\u001b[1;32m 413\u001b[0m \u001b[0msum_events\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 414\u001b[0m \u001b[0mcalculate_uncertainty\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 415\u001b[0;31m \u001b[0mweights_benchmark_uncertainties\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mweights_benchmark_uncertainties\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 416\u001b[0m )\n\u001b[1;32m 417\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Users/johannbrehmer/work/projects/madminer/madminer/madminer/fisherinformation.pyc\u001b[0m in \u001b[0;36m_calculate_fisher_information\u001b[0;34m(self, theta, weights_benchmarks, luminosity, include_nuisance_parameters, sum_events, calculate_uncertainty, weights_benchmark_uncertainties)\u001b[0m\n\u001b[1;32m 1041\u001b[0m \u001b[0;31m# Nuisance parameter Fisher info\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1042\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0minclude_nuisance_parameters\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minclude_nuisance_parameters\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1043\u001b[0;31m \u001b[0mnuisance_a\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnuisance_morpher\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalculate_a\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mweights_benchmarks\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Shape (n_nuisance_params, n_events)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1044\u001b[0m \u001b[0;31m# grad_i dsigma(x), where i is a nuisance parameter, is given by\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1045\u001b[0m \u001b[0;31m# sigma[np.newaxis, :] * a\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'calculate_a'" ] } ], @@ -400,7 +406,6 @@ "fisher_information, _ = fisher.calculate_fisher_information_full_detector(\n", " theta=[0.,0.],\n", " model_file='models/sally',\n", - " unweighted_x_sample_file='data/samples/x_test.npy',\n", " luminosity=3000000.\n", ")\n", "\n", @@ -416,32 +421,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/johannbrehmer/anaconda3/envs/python2/lib/python2.7/site-packages/matplotlib/contour.py:1004: UserWarning: The following kwargs were not used by contour: 'label'\n", - " s)\n", - "/Users/johannbrehmer/anaconda3/envs/python2/lib/python2.7/site-packages/matplotlib/cbook/deprecation.py:107: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", - " warnings.warn(message, mplDeprecation, stacklevel=1)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "_ = plot_fisher_information_contours_2d(\n", " [fisher_information],\n", @@ -466,11 +448,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "ensemble = EnsembleForge(estimators=5)" + "estimators = [ScoreEstimator(n_hidden=(20,)) for _ in range(5)]\n", + "\n", + "ensemble = Ensemble(estimators)" ] }, { @@ -489,269 +473,17 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": { "scrolled": false }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "09:32 madminer.ml INFO Training 5 estimators in ensemble\n", - "09:32 madminer.ml INFO Training estimator 1 / 5 in ensemble\n", - "09:32 madminer.ml INFO Starting training\n", - "09:32 madminer.ml INFO Method: sally\n", - "09:32 madminer.ml INFO Training data: x at data/samples/x_train.npy\n", - "09:32 madminer.ml INFO t_xz (theta0) at data/samples/t_xz_train.npy\n", - "09:32 madminer.ml INFO Features: all\n", - "09:32 madminer.ml INFO Method: sally\n", - "09:32 madminer.ml INFO Hidden layers: (100, 100)\n", - "09:32 madminer.ml INFO Activation function: tanh\n", - "09:32 madminer.ml INFO Batch size: 256\n", - "09:32 madminer.ml INFO Trainer: amsgrad\n", - "09:32 madminer.ml INFO Epochs: 20\n", - "09:32 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "09:32 madminer.ml INFO Validation split: 0.3\n", - "09:32 madminer.ml INFO Early stopping: True\n", - "09:32 madminer.ml INFO Scale inputs: True\n", - "09:32 madminer.ml INFO Shuffle labels False\n", - "09:32 madminer.ml INFO Regularization: None\n", - "09:32 madminer.ml INFO Samples: all\n", - "09:32 madminer.ml INFO Loading training data\n", - "09:32 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", - "09:32 madminer.ml INFO Rescaling inputs\n", - "09:32 madminer.ml INFO Creating model for method sally\n", - "09:32 madminer.ml INFO Training model\n", - "09:32 madminer.utils.ml.sc INFO Epoch 02: train loss 0.3376 (mse_score: 0.3376)\n", - "09:32 madminer.utils.ml.sc INFO val. loss 0.3613 (mse_score: 0.3613) (*)\n", - "09:32 madminer.utils.ml.sc INFO Epoch 04: train loss 0.3228 (mse_score: 0.3228)\n", - "09:32 madminer.utils.ml.sc INFO val. loss 0.3465 (mse_score: 0.3465) (*)\n", - "09:32 madminer.utils.ml.sc INFO Epoch 06: train loss 0.3177 (mse_score: 0.3177)\n", - "09:32 madminer.utils.ml.sc INFO val. loss 0.3448 (mse_score: 0.3448) (*)\n", - "09:33 madminer.utils.ml.sc INFO Epoch 08: train loss 0.3146 (mse_score: 0.3146)\n", - "09:33 madminer.utils.ml.sc INFO val. loss 0.3389 (mse_score: 0.3389) (*)\n", - "09:33 madminer.utils.ml.sc INFO Epoch 10: train loss 0.3120 (mse_score: 0.3120)\n", - "09:33 madminer.utils.ml.sc INFO val. loss 0.3394 (mse_score: 0.3394)\n", - "09:33 madminer.utils.ml.sc INFO Epoch 12: train loss 0.3109 (mse_score: 0.3109)\n", - "09:33 madminer.utils.ml.sc INFO val. loss 0.3379 (mse_score: 0.3379) (*)\n", - "09:33 madminer.utils.ml.sc INFO Epoch 14: train loss 0.3096 (mse_score: 0.3096)\n", - "09:33 madminer.utils.ml.sc INFO val. loss 0.3372 (mse_score: 0.3372) (*)\n", - "09:34 madminer.utils.ml.sc INFO Epoch 16: train loss 0.3091 (mse_score: 0.3091)\n", - "09:34 madminer.utils.ml.sc INFO val. loss 0.3370 (mse_score: 0.3370)\n", - "09:34 madminer.utils.ml.sc INFO Epoch 18: train loss 0.3085 (mse_score: 0.3085)\n", - "09:34 madminer.utils.ml.sc INFO val. loss 0.3358 (mse_score: 0.3358) (*)\n", - "09:34 madminer.utils.ml.sc INFO Epoch 20: train loss 0.3079 (mse_score: 0.3079)\n", - "09:34 madminer.utils.ml.sc INFO val. loss 0.3354 (mse_score: 0.3354) (*)\n", - "09:34 madminer.utils.ml.sc INFO Early stopping did not improve performance\n", - "09:34 madminer.utils.ml.sc INFO Finished training\n", - "09:34 madminer.ml INFO Training estimator 2 / 5 in ensemble\n", - "09:34 madminer.ml INFO Starting training\n", - "09:34 madminer.ml INFO Method: sally\n", - "09:34 madminer.ml INFO Training data: x at data/samples/x_train.npy\n", - "09:34 madminer.ml INFO t_xz (theta0) at data/samples/t_xz_train.npy\n", - "09:34 madminer.ml INFO Features: all\n", - "09:34 madminer.ml INFO Method: sally\n", - "09:34 madminer.ml INFO Hidden layers: (100, 100)\n", - "09:34 madminer.ml INFO Activation function: tanh\n", - "09:34 madminer.ml INFO Batch size: 256\n", - "09:34 madminer.ml INFO Trainer: amsgrad\n", - "09:34 madminer.ml INFO Epochs: 20\n", - "09:34 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "09:34 madminer.ml INFO Validation split: 0.3\n", - "09:34 madminer.ml INFO Early stopping: True\n", - "09:34 madminer.ml INFO Scale inputs: True\n", - "09:34 madminer.ml INFO Shuffle labels False\n", - "09:34 madminer.ml INFO Regularization: None\n", - "09:34 madminer.ml INFO Samples: all\n", - "09:34 madminer.ml INFO Loading training data\n", - "09:34 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", - "09:34 madminer.ml INFO Rescaling inputs\n", - "09:34 madminer.ml INFO Creating model for method sally\n", - "09:34 madminer.ml INFO Training model\n", - "09:35 madminer.utils.ml.sc INFO Epoch 02: train loss 0.3491 (mse_score: 0.3491)\n", - "09:35 madminer.utils.ml.sc INFO val. loss 0.3335 (mse_score: 0.3335) (*)\n", - "09:35 madminer.utils.ml.sc INFO Epoch 04: train loss 0.3325 (mse_score: 0.3325)\n", - "09:35 madminer.utils.ml.sc INFO val. loss 0.3232 (mse_score: 0.3232) (*)\n", - "09:35 madminer.utils.ml.sc INFO Epoch 06: train loss 0.3267 (mse_score: 0.3267)\n", - "09:35 madminer.utils.ml.sc INFO val. loss 0.3157 (mse_score: 0.3157) (*)\n", - "09:35 madminer.utils.ml.sc INFO Epoch 08: train loss 0.3244 (mse_score: 0.3244)\n", - "09:35 madminer.utils.ml.sc INFO val. loss 0.3125 (mse_score: 0.3125) (*)\n", - "09:36 madminer.utils.ml.sc INFO Epoch 10: train loss 0.3217 (mse_score: 0.3217)\n", - "09:36 madminer.utils.ml.sc INFO val. loss 0.3115 (mse_score: 0.3115) (*)\n", - "09:36 madminer.utils.ml.sc INFO Epoch 12: train loss 0.3200 (mse_score: 0.3200)\n", - "09:36 madminer.utils.ml.sc INFO val. loss 0.3101 (mse_score: 0.3101) (*)\n", - "09:36 madminer.utils.ml.sc INFO Epoch 14: train loss 0.3189 (mse_score: 0.3189)\n", - "09:36 madminer.utils.ml.sc INFO val. loss 0.3100 (mse_score: 0.3100) (*)\n", - "09:36 madminer.utils.ml.sc INFO Epoch 16: train loss 0.3184 (mse_score: 0.3184)\n", - "09:36 madminer.utils.ml.sc INFO val. loss 0.3097 (mse_score: 0.3097) (*)\n", - "09:37 madminer.utils.ml.sc INFO Epoch 18: train loss 0.3177 (mse_score: 0.3177)\n", - "09:37 madminer.utils.ml.sc INFO val. loss 0.3086 (mse_score: 0.3086) (*)\n", - "09:37 madminer.utils.ml.sc INFO Epoch 20: train loss 0.3171 (mse_score: 0.3171)\n", - "09:37 madminer.utils.ml.sc INFO val. loss 0.3081 (mse_score: 0.3081) (*)\n", - "09:37 madminer.utils.ml.sc INFO Early stopping did not improve performance\n", - "09:37 madminer.utils.ml.sc INFO Finished training\n", - "09:37 madminer.ml INFO Training estimator 3 / 5 in ensemble\n", - "09:37 madminer.ml INFO Starting training\n", - "09:37 madminer.ml INFO Method: sally\n", - "09:37 madminer.ml INFO Training data: x at data/samples/x_train.npy\n", - "09:37 madminer.ml INFO t_xz (theta0) at data/samples/t_xz_train.npy\n", - "09:37 madminer.ml INFO Features: all\n", - "09:37 madminer.ml INFO Method: sally\n", - "09:37 madminer.ml INFO Hidden layers: (100, 100)\n", - "09:37 madminer.ml INFO Activation function: tanh\n", - "09:37 madminer.ml INFO Batch size: 256\n", - "09:37 madminer.ml INFO Trainer: amsgrad\n", - "09:37 madminer.ml INFO Epochs: 20\n", - "09:37 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "09:37 madminer.ml INFO Validation split: 0.3\n", - "09:37 madminer.ml INFO Early stopping: True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "09:37 madminer.ml INFO Scale inputs: True\n", - "09:37 madminer.ml INFO Shuffle labels False\n", - "09:37 madminer.ml INFO Regularization: None\n", - "09:37 madminer.ml INFO Samples: all\n", - "09:37 madminer.ml INFO Loading training data\n", - "09:37 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", - "09:37 madminer.ml INFO Rescaling inputs\n", - "09:37 madminer.ml INFO Creating model for method sally\n", - "09:37 madminer.ml INFO Training model\n", - "09:37 madminer.utils.ml.sc INFO Epoch 02: train loss 0.3556 (mse_score: 0.3556)\n", - "09:37 madminer.utils.ml.sc INFO val. loss 0.3212 (mse_score: 0.3212) (*)\n", - "09:37 madminer.utils.ml.sc INFO Epoch 04: train loss 0.3382 (mse_score: 0.3382)\n", - "09:37 madminer.utils.ml.sc INFO val. loss 0.3126 (mse_score: 0.3126) (*)\n", - "09:37 madminer.utils.ml.sc INFO Epoch 06: train loss 0.3323 (mse_score: 0.3323)\n", - "09:37 madminer.utils.ml.sc INFO val. loss 0.3115 (mse_score: 0.3115)\n", - "09:38 madminer.utils.ml.sc INFO Epoch 08: train loss 0.3290 (mse_score: 0.3290)\n", - "09:38 madminer.utils.ml.sc INFO val. loss 0.3091 (mse_score: 0.3091) (*)\n", - "09:38 madminer.utils.ml.sc INFO Epoch 10: train loss 0.3274 (mse_score: 0.3274)\n", - "09:38 madminer.utils.ml.sc INFO val. loss 0.3053 (mse_score: 0.3053) (*)\n", - "09:38 madminer.utils.ml.sc INFO Epoch 12: train loss 0.3247 (mse_score: 0.3247)\n", - "09:38 madminer.utils.ml.sc INFO val. loss 0.3034 (mse_score: 0.3034) (*)\n", - "09:38 madminer.utils.ml.sc INFO Epoch 14: train loss 0.3241 (mse_score: 0.3241)\n", - "09:38 madminer.utils.ml.sc INFO val. loss 0.3051 (mse_score: 0.3051)\n", - "09:38 madminer.utils.ml.sc INFO Epoch 16: train loss 0.3225 (mse_score: 0.3225)\n", - "09:38 madminer.utils.ml.sc INFO val. loss 0.3032 (mse_score: 0.3032) (*)\n", - "09:39 madminer.utils.ml.sc INFO Epoch 18: train loss 0.3222 (mse_score: 0.3222)\n", - "09:39 madminer.utils.ml.sc INFO val. loss 0.3041 (mse_score: 0.3041)\n", - "09:39 madminer.utils.ml.sc INFO Epoch 20: train loss 0.3215 (mse_score: 0.3215)\n", - "09:39 madminer.utils.ml.sc INFO val. loss 0.3028 (mse_score: 0.3028)\n", - "09:39 madminer.utils.ml.sc INFO Early stopping after epoch 19, with loss 0.30 compared to final loss 0.30\n", - "09:39 madminer.utils.ml.sc INFO Finished training\n", - "09:39 madminer.ml INFO Training estimator 4 / 5 in ensemble\n", - "09:39 madminer.ml INFO Starting training\n", - "09:39 madminer.ml INFO Method: sally\n", - "09:39 madminer.ml INFO Training data: x at data/samples/x_train.npy\n", - "09:39 madminer.ml INFO t_xz (theta0) at data/samples/t_xz_train.npy\n", - "09:39 madminer.ml INFO Features: all\n", - "09:39 madminer.ml INFO Method: sally\n", - "09:39 madminer.ml INFO Hidden layers: (100, 100)\n", - "09:39 madminer.ml INFO Activation function: tanh\n", - "09:39 madminer.ml INFO Batch size: 256\n", - "09:39 madminer.ml INFO Trainer: amsgrad\n", - "09:39 madminer.ml INFO Epochs: 20\n", - "09:39 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "09:39 madminer.ml INFO Validation split: 0.3\n", - "09:39 madminer.ml INFO Early stopping: True\n", - "09:39 madminer.ml INFO Scale inputs: True\n", - "09:39 madminer.ml INFO Shuffle labels False\n", - "09:39 madminer.ml INFO Regularization: None\n", - "09:39 madminer.ml INFO Samples: all\n", - "09:39 madminer.ml INFO Loading training data\n", - "09:39 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", - "09:39 madminer.ml INFO Rescaling inputs\n", - "09:39 madminer.ml INFO Creating model for method sally\n", - "09:39 madminer.ml INFO Training model\n", - "09:39 madminer.utils.ml.sc INFO Epoch 02: train loss 0.3327 (mse_score: 0.3327)\n", - "09:39 madminer.utils.ml.sc INFO val. loss 0.3826 (mse_score: 0.3826) (*)\n", - "09:39 madminer.utils.ml.sc INFO Epoch 04: train loss 0.3174 (mse_score: 0.3174)\n", - "09:39 madminer.utils.ml.sc INFO val. loss 0.3637 (mse_score: 0.3637) (*)\n", - "09:39 madminer.utils.ml.sc INFO Epoch 06: train loss 0.3130 (mse_score: 0.3130)\n", - "09:39 madminer.utils.ml.sc INFO val. loss 0.3600 (mse_score: 0.3600) (*)\n", - "09:39 madminer.utils.ml.sc INFO Epoch 08: train loss 0.3100 (mse_score: 0.3100)\n", - "09:39 madminer.utils.ml.sc INFO val. loss 0.3564 (mse_score: 0.3564) (*)\n", - "09:40 madminer.utils.ml.sc INFO Epoch 10: train loss 0.3080 (mse_score: 0.3080)\n", - "09:40 madminer.utils.ml.sc INFO val. loss 0.3527 (mse_score: 0.3527) (*)\n", - "09:40 madminer.utils.ml.sc INFO Epoch 12: train loss 0.3062 (mse_score: 0.3062)\n", - "09:40 madminer.utils.ml.sc INFO val. loss 0.3519 (mse_score: 0.3519) (*)\n", - "09:40 madminer.utils.ml.sc INFO Epoch 14: train loss 0.3056 (mse_score: 0.3056)\n", - "09:40 madminer.utils.ml.sc INFO val. loss 0.3501 (mse_score: 0.3501) (*)\n", - "09:40 madminer.utils.ml.sc INFO Epoch 16: train loss 0.3044 (mse_score: 0.3044)\n", - "09:40 madminer.utils.ml.sc INFO val. loss 0.3499 (mse_score: 0.3499) (*)\n", - "09:40 madminer.utils.ml.sc INFO Epoch 18: train loss 0.3048 (mse_score: 0.3048)\n", - "09:40 madminer.utils.ml.sc INFO val. loss 0.3485 (mse_score: 0.3485)\n", - "09:40 madminer.utils.ml.sc INFO Epoch 20: train loss 0.3032 (mse_score: 0.3032)\n", - "09:40 madminer.utils.ml.sc INFO val. loss 0.3493 (mse_score: 0.3493)\n", - "09:40 madminer.utils.ml.sc INFO Early stopping after epoch 17, with loss 0.35 compared to final loss 0.35\n", - "09:40 madminer.utils.ml.sc INFO Finished training\n", - "09:40 madminer.ml INFO Training estimator 5 / 5 in ensemble\n", - "09:40 madminer.ml INFO Starting training\n", - "09:40 madminer.ml INFO Method: sally\n", - "09:40 madminer.ml INFO Training data: x at data/samples/x_train.npy\n", - "09:40 madminer.ml INFO t_xz (theta0) at data/samples/t_xz_train.npy\n", - "09:40 madminer.ml INFO Features: all\n", - "09:40 madminer.ml INFO Method: sally\n", - "09:40 madminer.ml INFO Hidden layers: (100, 100)\n", - "09:40 madminer.ml INFO Activation function: tanh\n", - "09:40 madminer.ml INFO Batch size: 256\n", - "09:40 madminer.ml INFO Trainer: amsgrad\n", - "09:40 madminer.ml INFO Epochs: 20\n", - "09:40 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "09:40 madminer.ml INFO Validation split: 0.3\n", - "09:40 madminer.ml INFO Early stopping: True\n", - "09:40 madminer.ml INFO Scale inputs: True\n", - "09:40 madminer.ml INFO Shuffle labels False\n", - "09:40 madminer.ml INFO Regularization: None\n", - "09:40 madminer.ml INFO Samples: all\n", - "09:40 madminer.ml INFO Loading training data\n", - "09:40 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", - "09:40 madminer.ml INFO Rescaling inputs\n", - "09:40 madminer.ml INFO Creating model for method sally\n", - "09:40 madminer.ml INFO Training model\n", - "09:41 madminer.utils.ml.sc INFO Epoch 02: train loss 0.3580 (mse_score: 0.3580)\n", - "09:41 madminer.utils.ml.sc INFO val. loss 0.3284 (mse_score: 0.3284) (*)\n", - "09:41 madminer.utils.ml.sc INFO Epoch 04: train loss 0.3385 (mse_score: 0.3385)\n", - "09:41 madminer.utils.ml.sc INFO val. loss 0.3179 (mse_score: 0.3179) (*)\n", - "09:41 madminer.utils.ml.sc INFO Epoch 06: train loss 0.3323 (mse_score: 0.3323)\n", - "09:41 madminer.utils.ml.sc INFO val. loss 0.3080 (mse_score: 0.3080) (*)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "09:41 madminer.utils.ml.sc INFO Epoch 08: train loss 0.3283 (mse_score: 0.3283)\n", - "09:41 madminer.utils.ml.sc INFO val. loss 0.3079 (mse_score: 0.3079) (*)\n", - "09:41 madminer.utils.ml.sc INFO Epoch 10: train loss 0.3257 (mse_score: 0.3257)\n", - "09:41 madminer.utils.ml.sc INFO val. loss 0.3052 (mse_score: 0.3052)\n", - "09:41 madminer.utils.ml.sc INFO Epoch 12: train loss 0.3241 (mse_score: 0.3241)\n", - "09:41 madminer.utils.ml.sc INFO val. loss 0.3027 (mse_score: 0.3027) (*)\n", - "09:42 madminer.utils.ml.sc INFO Epoch 14: train loss 0.3231 (mse_score: 0.3231)\n", - "09:42 madminer.utils.ml.sc INFO val. loss 0.3019 (mse_score: 0.3019) (*)\n", - "09:42 madminer.utils.ml.sc INFO Epoch 16: train loss 0.3218 (mse_score: 0.3218)\n", - "09:42 madminer.utils.ml.sc INFO val. loss 0.3027 (mse_score: 0.3027)\n", - "09:42 madminer.utils.ml.sc INFO Epoch 18: train loss 0.3206 (mse_score: 0.3206)\n", - "09:42 madminer.utils.ml.sc INFO val. loss 0.3012 (mse_score: 0.3012)\n", - "09:42 madminer.utils.ml.sc INFO Epoch 20: train loss 0.3207 (mse_score: 0.3207)\n", - "09:42 madminer.utils.ml.sc INFO val. loss 0.3014 (mse_score: 0.3014)\n", - "09:42 madminer.utils.ml.sc INFO Early stopping after epoch 17, with loss 0.30 compared to final loss 0.30\n", - "09:42 madminer.utils.ml.sc INFO Finished training\n" - ] - } - ], + "outputs": [], "source": [ "ensemble.train_all(\n", " method='sally',\n", - " x_filename='data/samples/x_train.npy',\n", - " t_xz0_filename='data/samples/t_xz_train.npy',\n", - " n_epochs=20,\n", - " batch_size=256,\n", - " validation_split=0.3\n", + " x='data/samples/x_train.npy',\n", + " t_xz='data/samples/t_xz_train.npy',\n", + " n_epochs=5,\n", ")\n", "\n", "ensemble.save('models/sally_ensemble')" @@ -778,28 +510,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "09:42 madminer.fisherinfor INFO Loading data from data/madminer_example_shuffled.h5\n", - "09:42 madminer.fisherinfor INFO Found 2 parameters\n", - "09:42 madminer.fisherinfor WARNING Did not find nuisance parameters!\n", - "09:42 madminer.fisherinfor INFO Found 6 benchmarks, of which 6 physical\n", - "09:42 madminer.fisherinfor INFO Found 2 observables: pt_j1, delta_phi_jj\n", - "09:42 madminer.fisherinfor INFO Found 46134 events\n", - "09:42 madminer.fisherinfor INFO Found morphing setup with 6 components\n", - "09:42 madminer.ml INFO Found ensemble with 5 estimators and expectations None\n", - "09:42 madminer.fisherinfor INFO Evaluating rate Fisher information\n", - "09:42 madminer.utils.inter WARNING include_nuisance_parameters=False without benchmark_is_nuisance information. Returning all weights.\n", - "09:42 madminer.utils.inter WARNING include_nuisance_parameters=False without benchmark_is_nuisance information. Returning all weights.\n", - "09:42 madminer.fisherinfor INFO Evaluating kinematic Fisher information on batch 1 / 1\n" - ] - } - ], + "outputs": [], "source": [ "fisher = FisherInformation('data/madminer_example_shuffled.h5')\n", "\n", @@ -820,22 +533,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "_ = plot_fisher_information_contours_2d(\n", " [fisher_information_mean],\n", diff --git a/examples/tutorial_delphes/3_systematic_uncertainties.ipynb b/examples/tutorial_delphes/3_systematic_uncertainties.ipynb new file mode 100755 index 000000000..d1f706149 --- /dev/null +++ b/examples/tutorial_delphes/3_systematic_uncertainties.ipynb @@ -0,0 +1,366 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MadMiner parton-level tutorial, part 3: Systematic uncertainties\n", + "\n", + "Johann Brehmer, Felix Kling, Kyle Cranmer 2018" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this tutorial we'll explain how to add systematic uncertainties to the MadMiner workflow." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preparations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before you execute this notebook, make sure you have running installations of MadGraph, Pythia, and Delphes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import absolute_import, division, print_function, unicode_literals\n", + "\n", + "import logging\n", + "import numpy as np\n", + "import matplotlib\n", + "from matplotlib import pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from madminer.core import MadMiner\n", + "from madminer.lhe import LHEReader\n", + "from madminer.sampling import combine_and_shuffle\n", + "from madminer.sampling import SampleAugmenter\n", + "from madminer import sampling\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Please enter here the path to your MG5 root directory." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mg_dir = '/Users/johannbrehmer/work/projects/madminer/MG5_aMC_v2_6_4'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "MadMiner uses the Python `logging` module to provide additional information and debugging output. You can choose how much of this output you want to see by switching the level in the following lines to `logging.DEBUG` or `logging.WARNING`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# MadMiner output\n", + "logging.basicConfig(\n", + " format='%(asctime)-5.5s %(name)-20.20s %(levelname)-7.7s %(message)s',\n", + " datefmt='%H:%M',\n", + " level=logging.INFO\n", + ")\n", + "\n", + "# Output of all other modules (e.g. matplotlib)\n", + "for key in logging.Logger.manager.loggerDict:\n", + " if \"madminer\" not in key:\n", + " logging.getLogger(key).setLevel(logging.WARNING)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1.-2. Parameters and benchmarks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll just load the MadMiner setup from the first part of this tutorial:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "miner = MadMiner()\n", + "miner.load('data/madminer_example.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Set up systematics, save settings, run MadGraph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is where things become interesting: We want to model systematic uncertainties. Currently this can be done in one of two ways: based on scale variation or based on PDF variations. You can also use both simultaneously. Here we just vary the scales:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "miner.set_systematics(scale_variation=(0.5,2.), pdf_variation=None)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we save our setup:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "miner.save('data/madminer_example_systematics.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now it's time to run MadGraph. MadMiner will instruct MadGraph to use its built-in `systematics` tool to calculate how the event weights change under the scale variation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "miner.run(\n", + " sample_benchmark='sm',\n", + " mg_directory=mg_dir,\n", + " mg_process_directory='./mg_processes/signal_systematics',\n", + " proc_card_file='cards/proc_card_signal.dat',\n", + " param_card_template_file='cards/param_card_template.dat',\n", + " run_card_file='cards/run_card_signal.dat',\n", + " log_directory='logs/signal',\n", + " python2_override=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Run smearing and extract observables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is just as before:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lhe = LHEReader('data/madminer_example_systematics.h5')\n", + "\n", + "lhe.add_sample(\n", + " lhe_filename='mg_processes/signal_systematics/Events/run_01/unweighted_events.lhe.gz',\n", + " sampled_from_benchmark='sm',\n", + " is_background=False,\n", + " k_factor=1.1,\n", + ")\n", + "\n", + "lhe.set_smearing(\n", + " pdgids=[1,2,3,4,5,6,9,22,-1,-2,-3,-4,-5,-6], # Partons giving rise to jets\n", + " energy_resolution_abs=0.,\n", + " energy_resolution_rel=0.1,\n", + " pt_resolution_abs=None,\n", + " pt_resolution_rel=None,\n", + " eta_resolution_abs=0.1,\n", + " eta_resolution_rel=0.,\n", + " phi_resolution_abs=0.1,\n", + " phi_resolution_rel=0.,\n", + ")\n", + "\n", + "lhe.add_observable(\n", + " 'pt_j1',\n", + " 'j[0].pt',\n", + " required=False,\n", + " default=0.,\n", + ")\n", + "lhe.add_observable(\n", + " 'delta_phi_jj',\n", + " 'j[0].deltaphi(j[1]) * (-1. + 2.*float(j[0].eta > j[1].eta))',\n", + " required=True,\n", + ")\n", + "lhe.add_observable(\n", + " 'met',\n", + " 'met.pt',\n", + " required=True,\n", + ")\n", + "\n", + "lhe.add_cut('(a[0] + a[1]).m > 124.')\n", + "lhe.add_cut('(a[0] + a[1]).m < 126.')\n", + "lhe.add_cut('pt_j1 > 30.')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "lhe.analyse_samples()\n", + "lhe.save('data/madminer_example_systematics_with_data.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A look at distributions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see what our MC run produced:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "_ = plot_uncertainty(\n", + " filename='data/madminer_example_systematics_with_data.h5',\n", + " parameter_points=['sm', np.array([10.,0.])],\n", + " line_labels=['SM', 'BSM'],\n", + " uncertainties='none',\n", + " n_bins=20,\n", + " n_cols=3,\n", + " normalize=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Make (unweighted) training and test samples with augmented data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sampler = SampleAugmenter('data/madminer_example_systematics_with_data.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When we generate training data, we now also have to specify the values of the nuisance parameters. The helper functions `sampling.nominal_nuisance_parameters()` and `sampling.iid_nuisance_parameters()` can be used in addition to the usual ones. The `theta0` and `theta1` return now includes values for the nuisance parameters." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x, theta0, theta1, y, r_xz, t_xz, _ = sampler.sample_train_ratio(\n", + " theta0=sampling.random_morphing_points(100, [('gaussian', 0., 15.), ('gaussian', 0., 15.)]),\n", + " theta1=sampling.benchmark('sm'),\n", + " nu0=sampling.iid_nuisance_parameters(\"gaussian\", 0., 1.),\n", + " nu1=sampling.nominal_nuisance_parameters(),\n", + " n_samples=1000,\n", + " folder='./data/samples',\n", + " filename='train'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To be continued..." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/tutorial_parton_level/1_from_cards_to_likelihood_ratio.ipynb b/examples/tutorial_parton_level/1_from_cards_to_likelihood_ratio.ipynb index 45dd305ab..a82aaa36f 100755 --- a/examples/tutorial_parton_level/1_from_cards_to_likelihood_ratio.ipynb +++ b/examples/tutorial_parton_level/1_from_cards_to_likelihood_ratio.ipynb @@ -49,12 +49,13 @@ "%matplotlib inline\n", "\n", "from madminer.core import MadMiner\n", - "from madminer.lhe import LHEProcessor\n", + "from madminer.lhe import LHEReader\n", "from madminer.sampling import combine_and_shuffle\n", "from madminer.sampling import SampleAugmenter\n", - "from madminer.sampling import constant_benchmark_theta, multiple_benchmark_thetas, random_morphing_thetas\n", - "from madminer.ml import MLForge\n", - "from madminer.plotting import plot_2d_morphing_basis, plot_distributions\n" + "from madminer import sampling\n", + "from madminer.ml import ParameterizedRatioEstimator\n", + "from madminer.plotting import plot_2d_morphing_basis, plot_distributions\n", + "from madminer.limits import AsymptoticLimits\n" ] }, { @@ -135,9 +136,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:57 madminer.core INFO Added parameter CWL2 (LHA: dim6 2, maximal power in squared ME: (2,), range: (-10.0, 10.0))\n", + "14:57 madminer.core INFO Added parameter CPWL2 (LHA: dim6 5, maximal power in squared ME: (2,), range: (-10.0, 1.0))\n" + ] + } + ], "source": [ "miner = MadMiner()\n", "\n", @@ -189,9 +199,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:57 madminer.core INFO Added benchmark sm: CWL2 = 0.00e+00, CPWL2 = 0.00e+00)\n", + "14:57 madminer.core INFO Added benchmark w: CWL2 = 10.00, CPWL2 = 0.00e+00)\n" + ] + } + ], "source": [ "miner.add_benchmark(\n", " {'CWL2':0., 'CPWL2':0.},\n", @@ -221,11 +240,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:57 madminer.core INFO Optimizing basis for morphing\n", + "14:57 madminer.utils.morph DEBUG Region 0: max overall power 2, max individual powers [2, 2]\n", + "14:57 madminer.utils.morph DEBUG Adding component [0 0]\n", + "14:57 madminer.utils.morph DEBUG Adding component [0 1]\n", + "14:57 madminer.utils.morph DEBUG Adding component [0 2]\n", + "14:57 madminer.utils.morph DEBUG Adding component [1 0]\n", + "14:57 madminer.utils.morph DEBUG Adding component [1 1]\n", + "14:57 madminer.utils.morph DEBUG Adding component [2 0]\n", + "14:57 madminer.core DEBUG Added benchmark sm: CWL2 = 0.00e+00, CPWL2 = 0.00e+00)\n", + "14:57 madminer.core DEBUG Added benchmark w: CWL2 = 10.00, CPWL2 = 0.00e+00)\n", + "14:57 madminer.core DEBUG Added benchmark morphing_basis_vector_2: CWL2 = -9.65e+00, CPWL2 = -4.70e-01)\n", + "14:57 madminer.core DEBUG Added benchmark morphing_basis_vector_3: CWL2 = -4.64e+00, CPWL2 = -3.84e+00)\n", + "14:57 madminer.core DEBUG Added benchmark morphing_basis_vector_4: CWL2 = 6.21, CPWL2 = -7.48e+00)\n", + "14:57 madminer.core DEBUG Added benchmark morphing_basis_vector_5: CWL2 = -7.38e+00, CPWL2 = -9.26e+00)\n", + "14:57 madminer.core INFO Set up morphing with 2 parameters, 6 morphing components, 2 predefined basis points, and 4 new basis points\n" + ] + } + ], "source": [ "miner.set_morphing(\n", " include_existing_benchmarks=True,\n", @@ -242,9 +283,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "fig = plot_2d_morphing_basis(\n", " miner.morpher,\n", @@ -264,9 +318,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:57 madminer.core INFO Saving setup (including morphing) to data/madminer_example.h5\n" + ] + } + ], "source": [ "miner.save('data/madminer_example.h5')" ] @@ -298,9 +360,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:57 madminer.utils.inter INFO Generating MadGraph process folder from cards/proc_card_signal.dat at ./mg_processes/signal\n", + "14:57 madminer.core INFO Run 0\n", + "14:57 madminer.core INFO Sampling from benchmark: sm\n", + "14:57 madminer.core INFO Original run card: cards/run_card_signal.dat\n", + "14:57 madminer.core INFO Original Pythia8 card: None\n", + "14:57 madminer.core INFO Copied run card: /madminer/cards/run_card_0.dat\n", + "14:57 madminer.core INFO Copied Pythia8 card: None\n", + "14:57 madminer.core INFO Param card: /madminer/cards/param_card_0.dat\n", + "14:57 madminer.core INFO Reweight card: /madminer/cards/reweight_card_0.dat\n", + "14:57 madminer.core INFO Log file: run_0.log\n", + "14:57 madminer.core INFO Creating param and reweight cards in ./mg_processes/signal//madminer/cards/param_card_0.dat, ./mg_processes/signal//madminer/cards/reweight_card_0.dat\n", + "14:57 madminer.utils.inter INFO Starting MadGraph and Pythia in ./mg_processes/signal\n", + "15:11 madminer.core INFO Finished running MadGraph! Please check that events were succesfully generated in the following folders:\n", + "\n", + "./mg_processes/signal/Events/run_01\n", + "\n", + "\n" + ] + } + ], "source": [ "miner.run(\n", " sample_benchmark='sm',\n", @@ -336,9 +422,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "\"\\nminer.run(\\n is_background=True,\\n sample_benchmark='sm',\\n mg_directory=mg_dir,\\n mg_process_directory='./mg_processes/background',\\n proc_card_file='cards/proc_card_background.dat',\\n param_card_template_file='cards/param_card_template.dat',\\n run_card_file='cards/run_card_background.dat',\\n log_directory='logs/background',\\n)\\n\"" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", "miner.run(\n", @@ -379,11 +476,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "15:11 madminer.utils.inter DEBUG HDF5 file does not contain is_reference field.\n" + ] + } + ], "source": [ - "proc = LHEProcessor('data/madminer_example.h5')" + "lhe = LHEReader('data/madminer_example.h5')" ] }, { @@ -397,13 +502,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "15:11 madminer.lhe DEBUG Adding event sample mg_processes/signal/Events/run_01/unweighted_events.lhe.gz\n" + ] + }, + { + "data": { + "text/plain": [ + "\"\\nlhe.add_sample(\\n lhe_filename='mg_processes/background/Events/run_01/unweighted_events.lhe.gz',\\n sampled_from_benchmark='sm',\\n is_background=True,\\n k_factor=1.0,\\n\"" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "proc.add_sample(\n", + "lhe.add_sample(\n", " lhe_filename='mg_processes/signal/Events/run_01/unweighted_events.lhe.gz',\n", " sampled_from_benchmark='sm',\n", " is_background=False,\n", @@ -411,7 +534,7 @@ ")\n", "\n", "\"\"\"\n", - "proc.add_sample(\n", + "lhe.add_sample(\n", " lhe_filename='mg_processes/background/Events/run_01/unweighted_events.lhe.gz',\n", " sampled_from_benchmark='sm',\n", " is_background=True,\n", @@ -428,11 +551,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "proc.set_smearing(\n", + "lhe.set_smearing(\n", " pdgids=[1,2,3,4,5,6,9,22,-1,-2,-3,-4,-5,-6], # Partons giving rise to jets\n", " energy_resolution_abs=0.,\n", " energy_resolution_rel=0.1,\n", @@ -460,22 +583,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "15:11 madminer.lhe DEBUG Adding optional observable pt_j1 = j[0].pt with default 0.0\n", + "15:11 madminer.lhe DEBUG Adding required observable delta_phi_jj = j[0].deltaphi(j[1]) * (-1. + 2.*float(j[0].eta > j[1].eta))\n", + "15:11 madminer.lhe DEBUG Adding required observable met = met.pt\n" + ] + } + ], "source": [ - "proc.add_observable(\n", + "lhe.add_observable(\n", " 'pt_j1',\n", " 'j[0].pt',\n", " required=False,\n", " default=0.,\n", ")\n", - "proc.add_observable(\n", + "lhe.add_observable(\n", " 'delta_phi_jj',\n", " 'j[0].deltaphi(j[1]) * (-1. + 2.*float(j[0].eta > j[1].eta))',\n", " required=True,\n", ")\n", - "proc.add_observable(\n", + "lhe.add_observable(\n", " 'met',\n", " 'met.pt',\n", " required=True,\n", @@ -491,13 +624,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "15:11 madminer.lhe DEBUG Adding cut (a[0] + a[1]).m > 124.\n", + "15:11 madminer.lhe DEBUG Adding cut (a[0] + a[1]).m < 126.\n", + "15:11 madminer.lhe DEBUG Adding cut pt_j1 > 30.\n" + ] + } + ], "source": [ - "proc.add_cut('(a[0] + a[1]).m > 124.')\n", - "proc.add_cut('(a[0] + a[1]).m < 126.')\n", - "proc.add_cut('pt_j1 > 30.')" + "lhe.add_cut('(a[0] + a[1]).m > 124.')\n", + "lhe.add_cut('(a[0] + a[1]).m < 126.')\n", + "lhe.add_cut('pt_j1 > 30.')" ] }, { @@ -509,13 +652,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "15:11 madminer.lhe INFO Analysing LHE sample mg_processes/signal/Events/run_01/unweighted_events.lhe.gz\n", + "15:11 madminer.lhe DEBUG Extracting nuisance parameter definitions from LHE file\n", + "15:11 madminer.utils.inter DEBUG Parsing nuisance parameter setup from LHE file at mg_processes/signal/Events/run_01/unweighted_events.lhe.gz\n", + "15:11 madminer.lhe DEBUG Found 0 nuisance parameters with matching benchmarks:\n", + "15:11 madminer.utils.inter DEBUG Parsing LHE file mg_processes/signal/Events/run_01/unweighted_events.lhe.gz\n", + "15:11 madminer.utils.inter DEBUG Parsing header and events as XML with cElementTree\n", + "15:11 madminer.utils.inter DEBUG Found entry event_norm = sum in LHE header. Interpreting this as weight_norm_is_average = False.\n", + "15:12 madminer.utils.inter DEBUG 51298 / 100000 events pass cut (a[0] + a[1]).m > 124.\n", + "15:12 madminer.utils.inter DEBUG 55361 / 100000 events pass cut (a[0] + a[1]).m < 126.\n", + "15:12 madminer.utils.inter DEBUG 98414 / 100000 events pass cut pt_j1 > 30.\n", + "15:12 madminer.utils.inter INFO 6557 events pass all cuts\n", + "15:12 madminer.lhe DEBUG Found weights ['sm', 'w', 'morphing_basis_vector_2', 'morphing_basis_vector_3', 'morphing_basis_vector_4', 'morphing_basis_vector_5'] in LHE file\n", + "15:12 madminer.lhe DEBUG Found 6557 events\n" + ] + } + ], "source": [ - "proc.analyse_samples()" + "lhe.analyse_samples()" ] }, { @@ -527,11 +690,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "15:12 madminer.lhe DEBUG Loading HDF5 data from data/madminer_example.h5 and saving file to data/madminer_example_with_data2.h5\n", + "15:12 madminer.lhe DEBUG Weight names: ['sm', 'w', 'morphing_basis_vector_2', 'morphing_basis_vector_3', 'morphing_basis_vector_4', 'morphing_basis_vector_5']\n", + "15:12 madminer.utils.inter DEBUG Benchmarks found in HDF5 file: ['sm', 'w', 'morphing_basis_vector_2', 'morphing_basis_vector_3', 'morphing_basis_vector_4', 'morphing_basis_vector_5']\n", + "15:12 madminer.utils.inter DEBUG Benchmark morphing_basis_vector_2 already in benchmark_names_phys\n", + "15:12 madminer.utils.inter DEBUG Benchmark morphing_basis_vector_3 already in benchmark_names_phys\n", + "15:12 madminer.utils.inter DEBUG Benchmark morphing_basis_vector_4 already in benchmark_names_phys\n", + "15:12 madminer.utils.inter DEBUG Benchmark morphing_basis_vector_5 already in benchmark_names_phys\n", + "15:12 madminer.utils.inter DEBUG Benchmark sm already in benchmark_names_phys\n", + "15:12 madminer.utils.inter DEBUG Benchmark w already in benchmark_names_phys\n", + "15:12 madminer.utils.inter DEBUG Combined benchmark names: ['sm', 'w', 'morphing_basis_vector_2', 'morphing_basis_vector_3', 'morphing_basis_vector_4', 'morphing_basis_vector_5']\n", + "15:12 madminer.utils.inter DEBUG Combined is_nuisance: [0 0 0 0 0 0]\n", + "15:12 madminer.utils.inter DEBUG Combined is_reference: [1 0 0 0 0 0]\n", + "15:12 madminer.utils.inter DEBUG Weight names found in event file: ['sm', 'w', 'morphing_basis_vector_2', 'morphing_basis_vector_3', 'morphing_basis_vector_4', 'morphing_basis_vector_5']\n", + "15:12 madminer.utils.inter DEBUG Benchmarks found in MadMiner file: ['sm', 'w', 'morphing_basis_vector_2', 'morphing_basis_vector_3', 'morphing_basis_vector_4', 'morphing_basis_vector_5']\n", + "15:12 madminer.utils.inter DEBUG Sorted benchmarks: ['sm', 'w', 'morphing_basis_vector_2', 'morphing_basis_vector_3', 'morphing_basis_vector_4', 'morphing_basis_vector_5']\n" + ] + } + ], "source": [ - "proc.save('data/madminer_example_with_data2.h5')" + "lhe.save('data/madminer_example_with_data2.h5')" ] }, { @@ -550,9 +735,55 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "15:21 madminer.analysis INFO Loading data from data/madminer_example_with_data2.h5\n", + "15:21 madminer.analysis INFO Found 2 parameters\n", + "15:21 madminer.analysis DEBUG CWL2 (LHA: dim6 2, maximal power in squared ME: (2,), range: (-10.0, 10.0))\n", + "15:21 madminer.analysis DEBUG CPWL2 (LHA: dim6 5, maximal power in squared ME: (2,), range: (-10.0, 1.0))\n", + "15:21 madminer.analysis INFO Did not find nuisance parameters\n", + "15:21 madminer.analysis INFO Found 6 benchmarks, of which 6 physical\n", + "15:21 madminer.analysis DEBUG sm: CWL2 = 0.00e+00, CPWL2 = 0.00e+00\n", + "15:21 madminer.analysis DEBUG w: CWL2 = 10.00, CPWL2 = 0.00e+00\n", + "15:21 madminer.analysis DEBUG morphing_basis_vector_2: CWL2 = -9.65e+00, CPWL2 = -4.70e-01\n", + "15:21 madminer.analysis DEBUG morphing_basis_vector_3: CWL2 = -4.64e+00, CPWL2 = -3.84e+00\n", + "15:21 madminer.analysis DEBUG morphing_basis_vector_4: CWL2 = 6.21, CPWL2 = -7.48e+00\n", + "15:21 madminer.analysis DEBUG morphing_basis_vector_5: CWL2 = -7.38e+00, CPWL2 = -9.26e+00\n", + "15:21 madminer.analysis INFO Found 3 observables\n", + "15:21 madminer.analysis DEBUG 0 pt_j1\n", + "15:21 madminer.analysis DEBUG 1 delta_phi_jj\n", + "15:21 madminer.analysis DEBUG 2 met\n", + "15:21 madminer.analysis INFO Found 6557 events\n", + "15:21 madminer.analysis INFO Found morphing setup with 6 components\n", + "15:21 madminer.plotting DEBUG Observable indices: [0, 1, 2]\n", + "15:21 madminer.plotting DEBUG Loaded raw data with shapes (6557, 3), (6557, 6)\n", + "15:21 madminer.plotting DEBUG Calculated 2 theta matrices\n", + "15:21 madminer.plotting DEBUG Plotting panel 0: observable 0, label pt_j1\n", + "15:21 madminer.plotting DEBUG Ranges for observable pt_j1: min = [30.00272214753616, 30.00272214753616], max = [268.4365868483533, 643.8710663910911]\n", + "15:21 madminer.plotting DEBUG Plotting panel 1: observable 1, label delta_phi_jj\n", + "15:21 madminer.plotting DEBUG Ranges for observable delta_phi_jj: min = [-3.13993286774336, -3.13993286774336], max = [3.138627963883186, 3.138627963883186]\n", + "15:21 madminer.plotting DEBUG Plotting panel 2: observable 2, label met\n", + "15:21 madminer.plotting DEBUG Ranges for observable met: min = [0.005806845822755466, 0.005806845822755466], max = [76.87778563467432, 178.33162311405053]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "_ = plot_distributions(\n", " filename='data/madminer_example_with_data2.h5',\n", @@ -583,9 +814,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "15:21 madminer.sampling DEBUG Combining and shuffling samples\n", + "15:21 madminer.sampling INFO Copying setup from data/madminer_example_with_data.h5 to data/madminer_example_shuffled.h5\n", + "15:21 madminer.sampling INFO Loading samples from file 1 / 1 at data/madminer_example_with_data.h5, multiplying weights with k factor 1.0\n" + ] + } + ], "source": [ "combine_and_shuffle(\n", " ['data/madminer_example_with_data.h5'],\n", @@ -613,11 +854,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "15:32 madminer.analysis INFO Loading data from data/madminer_example_shuffled.h5\n", + "15:32 madminer.analysis INFO Found 2 parameters\n", + "15:32 madminer.analysis INFO Did not find nuisance parameters\n", + "15:32 madminer.analysis INFO Found 6 benchmarks, of which 6 physical\n", + "15:32 madminer.analysis INFO Found 2 observables\n", + "15:32 madminer.analysis INFO Found 6537 events\n", + "15:32 madminer.analysis INFO Found morphing setup with 6 components\n" + ] + } + ], "source": [ - "sa = SampleAugmenter('data/madminer_example_shuffled.h5')" + "sampler = SampleAugmenter('data/madminer_example_shuffled.h5')" ] }, { @@ -625,26 +880,40 @@ "metadata": {}, "source": [ "The `SampleAugmenter` class defines five different high-level functions to generate train or test samples:\n", - "- `extract_samples_train_plain()`, which only saves observations x, for instance for histograms or ABC;\n", - "- `extract_samples_train_local()` for methods like SALLY and SALLINO, which will be demonstrated in the second part of the tutorial;\n", - "- `extract_samples_train_ratio()` for techniques like CARL, ROLR, CASCAL, and RASCAL, when only theta0 is parameterized;\n", - "- `extract_samples_train_more_ratios()` for the same techniques, but with both theta0 and theta1 parameterized;\n", - "- `extract_samples_test()` for the evaluation of any method.\n", + "- `sample_train_plain()`, which only saves observations x, for instance for histograms or ABC;\n", + "- `sample_train_local()` for methods like SALLY and SALLINO, which will be demonstrated in the second part of the tutorial;\n", + "- `sample_train_density()` for neural density estimation techniques like MAF or SCANDAL;\n", + "- `sample_train_ratio()` for techniques like CARL, ROLR, CASCAL, and RASCAL, when only theta0 is parameterized;\n", + "- `sample_train_more_ratios()` for the same techniques, but with both theta0 and theta1 parameterized;\n", + "- `sample_test()` for the evaluation of any method.\n", "\n", - "For the arguments `theta`, `theta0`, or `theta1`, you can (and should!) use the helper functions `constant_benchmark_theta()`, `multiple_benchmark_thetas()`, `constant_morphing_theta()`, `multiple_morphing_thetas()`, and `random_morphing_thetas()`, all defined in the `madminer.sampling` module.\n", + "For the arguments `theta`, `theta0`, or `theta1`, you can (and should!) use the helper functions `benchmark()`, `benchmarks()`, `morphing_point()`, `morphing_points()`, and `random_morphing_points()`, all defined in the `madminer.sampling` module.\n", "\n", "Here we'll train a likelihood ratio estimator with the ALICES method, so we focus on the `extract_samples_train_ratio()` function." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "15:32 madminer.sampling INFO Extracting training sample for ratio-based methods. Numerator hypothesis: ('random_morphing_points', (100, [('gaussian', 0.0, 15.0), ('gaussian', 0.0, 15.0)])), denominator hypothesis: ('benchmark', 'sm')\n", + "/Users/johannbrehmer/work/projects/madminer/madminer/madminer/analysis.py:284: RuntimeWarning: invalid value encountered in sqrt\n", + " xsec_uncertainties = xsec_uncertainties ** 0.5\n", + "15:32 madminer.sampling WARNING Large statistical uncertainty on the total cross section when sampling from theta = [4.59589697 7.76994673]: (0.000720 +/- 0.000073) pb (10.124460729467307 %). Skipping these warnings in the future...\n", + "15:32 madminer.sampling INFO Effective number of samples: mean 16.457179431399243, with individual thetas ranging from 7.197251196742754 to 68.10093524160831\n", + "15:32 madminer.sampling INFO Effective number of samples: mean 5230.0, with individual thetas ranging from 5230.0 to 5230.0\n" + ] + } + ], "source": [ - "x, theta0, theta1, y, r_xz, t_xz = sa.extract_samples_train_ratio(\n", - " theta0=random_morphing_thetas(100, [('gaussian', 0., 10.), ('gaussian', 0., 10.)]),\n", - " theta1=constant_benchmark_theta('sm'),\n", + "x, theta0, theta1, y, r_xz, t_xz, _ = sampler.sample_train_ratio(\n", + " theta0=sampling.random_morphing_points(100, [('gaussian', 0., 15.), ('gaussian', 0., 15.)]),\n", + " theta1=sampling.benchmark('sm'),\n", " n_samples=100000,\n", " folder='./data/samples',\n", " filename='train'\n", @@ -660,15 +929,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "15:32 madminer.sampling INFO Extracting evaluation sample. Sampling according to ('benchmark', 'sm')\n", + "15:32 madminer.sampling INFO Effective number of samples: 1306.0000000000002\n" + ] + } + ], "source": [ - "_ = sa.extract_samples_test(\n", - " theta=constant_benchmark_theta('sm'),\n", - " n_samples=100000,\n", + "_ = sampler.sample_test(\n", + " theta=sampling.benchmark('sm'),\n", + " n_samples=1000,\n", " folder='./data/samples',\n", " filename='test'\n", ")" @@ -690,24 +968,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "15:32 madminer.sampling INFO Starting cross-section calculation\n", + "15:32 madminer.sampling INFO Starting cross-section calculation\n" + ] + } + ], "source": [ - "thetas_benchmarks, xsecs_benchmarks, xsec_errors_benchmarks = sa.extract_cross_sections(\n", - " theta=multiple_benchmark_thetas(['sm', 'w', 'morphing_basis_vector_2', 'morphing_basis_vector_3', 'morphing_basis_vector_4', 'morphing_basis_vector_5'])\n", + "thetas_benchmarks, xsecs_benchmarks, xsec_errors_benchmarks = sampler.cross_sections(\n", + " theta=sampling.benchmarks(['sm', 'w', 'morphing_basis_vector_2', 'morphing_basis_vector_3', 'morphing_basis_vector_4', 'morphing_basis_vector_5'])\n", ")\n", "\n", - "thetas_morphing, xsecs_morphing, xsec_errors_morphing = sa.extract_cross_sections(\n", - " theta=random_morphing_thetas(1000, [('gaussian', 0., 4.), ('gaussian', 0., 4.)])\n", + "thetas_morphing, xsecs_morphing, xsec_errors_morphing = sampler.cross_sections(\n", + " theta=sampling.random_morphing_points(1000, [('gaussian', 0., 4.), ('gaussian', 0., 4.)])\n", ")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "cmin, cmax = 0., 2.5 * np.mean(xsecs_morphing)\n", "\n", @@ -748,16 +1048,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "It's now time to build the neural network that estimates the likelihood ratio. The central object for this is the `madminer.ml.MLForge` class. It defines functions that train, save, load, and evaluate the estimators." + "It's now time to build the neural network that estimates the likelihood ratio. The central object for this is the `madminer.ml.ParameterizedRatioEstimator` class. It defines functions that train, save, load, and evaluate the estimators.\n", + "\n", + "In the initialization, the keywords `n_hidden` and `activation` define the architecture of the (fully connected) neural network:" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "forge = MLForge()" + "estimator = ParameterizedRatioEstimator(\n", + " n_hidden=(100,),\n", + " activation=\"tanh\"\n", + ")" ] }, { @@ -771,104 +1076,92 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We will use the ALICES technique described in [\"Likelihood-free inference with an improved cross-entropy estimator\"](https://arxiv.org/abs/1808.00973). Most other methods, including RASCAL, are described in [\"Constraining Effective Field Theories With Machine Learning\"](https://arxiv.org/abs/1805.00013) and [\"A Guide to Constraining Effective Field Theories With Machine Learning\"](https://arxiv.org/abs/1805.00020). There is also SCANDAL introduced in [\"Mining gold from implicit models to improve likelihood-free inference\"](https://arxiv.org/abs/1805.12244).\n", - "\n", - "Most of these methods exist both in a \"single parameterized\" version, in which only the dependence of the likelihood ratio on the numerator is modelled, and a \"doubly parameterized\" version, in which both the dependence on the numerator and denominator parameters is modelled. For the single parameterized version, use `method='rascal'`, `method='alice'`, and so on. For the double parameterized version, use `method='rascal2'`, `method='alice2'`, etc. Note that for the doubly parameterized estimators you have to provide `theta1_filename`, and in the case of RASCAL and ALICES also `t_xz1_filename`." + "To train this model we will minimize the ALICES loss function described in [\"Likelihood-free inference with an improved cross-entropy estimator\"](https://arxiv.org/abs/1808.00973). Many alternatives, including RASCAL, are described in [\"Constraining Effective Field Theories With Machine Learning\"](https://arxiv.org/abs/1805.00013) and [\"A Guide to Constraining Effective Field Theories With Machine Learning\"](https://arxiv.org/abs/1805.00020). There is also SCANDAL introduced in [\"Mining gold from implicit models to improve likelihood-free inference\"](https://arxiv.org/abs/1805.12244)." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "18:02 madminer.ml INFO Starting training\n", - "18:02 madminer.ml INFO Method: alices\n", - "18:02 madminer.ml INFO Training data: x at data/samples/x_train.npy\n", - "18:02 madminer.ml INFO theta0 at data/samples/theta0_train.npy\n", - "18:02 madminer.ml INFO y at data/samples/y_train.npy\n", - "18:02 madminer.ml INFO r_xz at data/samples/r_xz_train.npy\n", - "18:02 madminer.ml INFO t_xz (theta0) at data/samples/t_xz_train.npy\n", - "18:02 madminer.ml INFO Features: all\n", - "18:02 madminer.ml INFO Method: alices\n", - "18:02 madminer.ml INFO Hidden layers: (20, 20)\n", - "18:02 madminer.ml INFO Activation function: tanh\n", - "18:02 madminer.ml INFO alpha: 10.0\n", - "18:02 madminer.ml INFO Batch size: 200\n", - "18:02 madminer.ml INFO Optimizer: amsgrad\n", - "18:02 madminer.ml INFO Epochs: 20\n", - "18:02 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "18:02 madminer.ml INFO Validation split: 0.25\n", - "18:02 madminer.ml INFO Early stopping: True\n", - "18:02 madminer.ml INFO Scale inputs: True\n", - "18:02 madminer.ml INFO Shuffle labels False\n", - "18:02 madminer.ml INFO Samples: all\n", - "18:02 madminer.ml INFO Loading training data\n", - "18:02 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", - "18:02 madminer.ml INFO Rescaling inputs\n", - "18:02 madminer.ml INFO Creating model for method alices\n", - "18:02 madminer.ml INFO Training model\n", - "18:03 madminer.utils.ml.tr INFO Epoch 1: train loss 0.65668 (improved_xe: 0.558, mse_score: 0.010)\n", - "18:03 madminer.utils.ml.tr INFO val. loss 0.60964 (improved_xe: 0.512, mse_score: 0.010)\n", - "18:03 madminer.utils.ml.tr INFO Epoch 2: train loss 0.58610 (improved_xe: 0.505, mse_score: 0.008)\n", - "18:03 madminer.utils.ml.tr INFO val. loss 0.58834 (improved_xe: 0.501, mse_score: 0.009)\n", - "18:03 madminer.utils.ml.tr INFO Epoch 3: train loss 0.56904 (improved_xe: 0.494, mse_score: 0.008)\n", - "18:03 madminer.utils.ml.tr INFO val. loss 0.57285 (improved_xe: 0.490, mse_score: 0.008)\n", - "18:04 madminer.utils.ml.tr INFO Epoch 4: train loss 0.55583 (improved_xe: 0.484, mse_score: 0.007)\n", - "18:04 madminer.utils.ml.tr INFO val. loss 0.56233 (improved_xe: 0.482, mse_score: 0.008)\n", - "18:04 madminer.utils.ml.tr INFO Epoch 5: train loss 0.54887 (improved_xe: 0.479, mse_score: 0.007)\n", - "18:04 madminer.utils.ml.tr INFO val. loss 0.55753 (improved_xe: 0.480, mse_score: 0.008)\n", - "18:04 madminer.utils.ml.tr INFO Epoch 6: train loss 0.54480 (improved_xe: 0.477, mse_score: 0.007)\n", - "18:04 madminer.utils.ml.tr INFO val. loss 0.55427 (improved_xe: 0.478, mse_score: 0.008)\n", - "18:04 madminer.utils.ml.tr INFO Epoch 7: train loss 0.54193 (improved_xe: 0.476, mse_score: 0.007)\n", - "18:04 madminer.utils.ml.tr INFO val. loss 0.55197 (improved_xe: 0.477, mse_score: 0.007)\n", - "18:05 madminer.utils.ml.tr INFO Epoch 8: train loss 0.53994 (improved_xe: 0.475, mse_score: 0.006)\n", - "18:05 madminer.utils.ml.tr INFO val. loss 0.55032 (improved_xe: 0.476, mse_score: 0.007)\n", - "18:05 madminer.utils.ml.tr INFO Epoch 9: train loss 0.53810 (improved_xe: 0.474, mse_score: 0.006)\n", - "18:05 madminer.utils.ml.tr INFO val. loss 0.54881 (improved_xe: 0.476, mse_score: 0.007)\n", - "18:05 madminer.utils.ml.tr INFO Epoch 10: train loss 0.53668 (improved_xe: 0.474, mse_score: 0.006)\n", - "18:05 madminer.utils.ml.tr INFO val. loss 0.54846 (improved_xe: 0.476, mse_score: 0.007)\n", - "18:05 madminer.utils.ml.tr INFO Epoch 11: train loss 0.53568 (improved_xe: 0.473, mse_score: 0.006)\n", - "18:05 madminer.utils.ml.tr INFO val. loss 0.54705 (improved_xe: 0.475, mse_score: 0.007)\n", - "18:06 madminer.utils.ml.tr INFO Epoch 12: train loss 0.53473 (improved_xe: 0.473, mse_score: 0.006)\n", - "18:06 madminer.utils.ml.tr INFO val. loss 0.54593 (improved_xe: 0.474, mse_score: 0.007)\n", - "18:06 madminer.utils.ml.tr INFO Epoch 13: train loss 0.53400 (improved_xe: 0.473, mse_score: 0.006)\n", - "18:06 madminer.utils.ml.tr INFO val. loss 0.54547 (improved_xe: 0.474, mse_score: 0.007)\n", - "18:06 madminer.utils.ml.tr INFO Epoch 14: train loss 0.53337 (improved_xe: 0.472, mse_score: 0.006)\n", - "18:06 madminer.utils.ml.tr INFO val. loss 0.54500 (improved_xe: 0.474, mse_score: 0.007)\n", - "18:07 madminer.utils.ml.tr INFO Epoch 15: train loss 0.53283 (improved_xe: 0.472, mse_score: 0.006)\n", - "18:07 madminer.utils.ml.tr INFO val. loss 0.54444 (improved_xe: 0.473, mse_score: 0.007)\n", - "18:07 madminer.utils.ml.tr INFO Epoch 16: train loss 0.53243 (improved_xe: 0.472, mse_score: 0.006)\n", - "18:07 madminer.utils.ml.tr INFO val. loss 0.54418 (improved_xe: 0.473, mse_score: 0.007)\n", - "18:07 madminer.utils.ml.tr INFO Epoch 17: train loss 0.53203 (improved_xe: 0.472, mse_score: 0.006)\n", - "18:07 madminer.utils.ml.tr INFO val. loss 0.54378 (improved_xe: 0.473, mse_score: 0.007)\n", - "18:07 madminer.utils.ml.tr INFO Epoch 18: train loss 0.53167 (improved_xe: 0.472, mse_score: 0.006)\n", - "18:07 madminer.utils.ml.tr INFO val. loss 0.54368 (improved_xe: 0.473, mse_score: 0.007)\n", - "18:08 madminer.utils.ml.tr INFO Epoch 19: train loss 0.53139 (improved_xe: 0.471, mse_score: 0.006)\n", - "18:08 madminer.utils.ml.tr INFO val. loss 0.54336 (improved_xe: 0.473, mse_score: 0.007)\n", - "18:08 madminer.utils.ml.tr INFO Epoch 20: train loss 0.53117 (improved_xe: 0.471, mse_score: 0.006)\n", - "18:08 madminer.utils.ml.tr INFO val. loss 0.54308 (improved_xe: 0.473, mse_score: 0.007)\n", - "18:08 madminer.utils.ml.tr INFO Early stopping did not improve performance\n" + "15:32 madminer.ml INFO Starting training\n", + "15:32 madminer.ml INFO Method: alices\n", + "15:32 madminer.ml INFO alpha: 1.0\n", + "15:32 madminer.ml INFO Batch size: 200\n", + "15:32 madminer.ml INFO Optimizer: amsgrad\n", + "15:32 madminer.ml INFO Epochs: 20\n", + "15:32 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", + "15:32 madminer.ml INFO Validation split: 0.25\n", + "15:32 madminer.ml INFO Early stopping: True\n", + "15:32 madminer.ml INFO Scale inputs: True\n", + "15:32 madminer.ml INFO Shuffle labels False\n", + "15:32 madminer.ml INFO Samples: all\n", + "15:32 madminer.ml INFO Loading training data\n", + "15:32 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", + "15:32 madminer.ml INFO Rescaling inputs\n", + "15:32 madminer.ml INFO Creating model\n", + "15:32 madminer.ml INFO Training model\n", + "15:32 madminer.utils.ml.tr INFO Epoch 1: train loss 0.54737 (improved_xe: 0.541, mse_score: 0.007)\n", + "15:32 madminer.utils.ml.tr INFO val. loss 0.47317 (improved_xe: 0.466, mse_score: 0.007)\n", + "15:33 madminer.utils.ml.tr INFO Epoch 2: train loss 0.46643 (improved_xe: 0.460, mse_score: 0.006)\n", + "15:33 madminer.utils.ml.tr INFO val. loss 0.46405 (improved_xe: 0.458, mse_score: 0.006)\n", + "15:33 madminer.utils.ml.tr INFO Epoch 3: train loss 0.45810 (improved_xe: 0.452, mse_score: 0.006)\n", + "15:33 madminer.utils.ml.tr INFO val. loss 0.45854 (improved_xe: 0.453, mse_score: 0.006)\n", + "15:33 madminer.utils.ml.tr INFO Epoch 4: train loss 0.45234 (improved_xe: 0.447, mse_score: 0.005)\n", + "15:33 madminer.utils.ml.tr INFO val. loss 0.45217 (improved_xe: 0.447, mse_score: 0.005)\n", + "15:34 madminer.utils.ml.tr INFO Epoch 5: train loss 0.44889 (improved_xe: 0.444, mse_score: 0.005)\n", + "15:34 madminer.utils.ml.tr INFO val. loss 0.44919 (improved_xe: 0.444, mse_score: 0.005)\n", + "15:34 madminer.utils.ml.tr INFO Epoch 6: train loss 0.44669 (improved_xe: 0.442, mse_score: 0.005)\n", + "15:34 madminer.utils.ml.tr INFO val. loss 0.44713 (improved_xe: 0.442, mse_score: 0.005)\n", + "15:34 madminer.utils.ml.tr INFO Epoch 7: train loss 0.44523 (improved_xe: 0.440, mse_score: 0.005)\n", + "15:34 madminer.utils.ml.tr INFO val. loss 0.44619 (improved_xe: 0.441, mse_score: 0.005)\n", + "15:35 madminer.utils.ml.tr INFO Epoch 8: train loss 0.44404 (improved_xe: 0.439, mse_score: 0.005)\n", + "15:35 madminer.utils.ml.tr INFO val. loss 0.44569 (improved_xe: 0.440, mse_score: 0.005)\n", + "15:35 madminer.utils.ml.tr INFO Epoch 9: train loss 0.44324 (improved_xe: 0.438, mse_score: 0.005)\n", + "15:35 madminer.utils.ml.tr INFO val. loss 0.44442 (improved_xe: 0.439, mse_score: 0.005)\n", + "15:35 madminer.utils.ml.tr INFO Epoch 10: train loss 0.44241 (improved_xe: 0.437, mse_score: 0.005)\n", + "15:35 madminer.utils.ml.tr INFO val. loss 0.44384 (improved_xe: 0.439, mse_score: 0.005)\n", + "15:36 madminer.utils.ml.tr INFO Epoch 11: train loss 0.44188 (improved_xe: 0.437, mse_score: 0.005)\n", + "15:36 madminer.utils.ml.tr INFO val. loss 0.44329 (improved_xe: 0.438, mse_score: 0.005)\n", + "15:36 madminer.utils.ml.tr INFO Epoch 12: train loss 0.44136 (improved_xe: 0.436, mse_score: 0.005)\n", + "15:36 madminer.utils.ml.tr INFO val. loss 0.44285 (improved_xe: 0.438, mse_score: 0.005)\n", + "15:36 madminer.utils.ml.tr INFO Epoch 13: train loss 0.44094 (improved_xe: 0.436, mse_score: 0.005)\n", + "15:36 madminer.utils.ml.tr INFO val. loss 0.44295 (improved_xe: 0.438, mse_score: 0.005)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 14: train loss 0.44062 (improved_xe: 0.436, mse_score: 0.005)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.44229 (improved_xe: 0.437, mse_score: 0.005)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 15: train loss 0.44041 (improved_xe: 0.435, mse_score: 0.005)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.44202 (improved_xe: 0.437, mse_score: 0.005)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 16: train loss 0.44015 (improved_xe: 0.435, mse_score: 0.005)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.44186 (improved_xe: 0.437, mse_score: 0.005)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 17: train loss 0.43990 (improved_xe: 0.435, mse_score: 0.005)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.44159 (improved_xe: 0.436, mse_score: 0.005)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 18: train loss 0.43973 (improved_xe: 0.435, mse_score: 0.005)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.44156 (improved_xe: 0.436, mse_score: 0.005)\n", + "15:39 madminer.utils.ml.tr INFO Epoch 19: train loss 0.43957 (improved_xe: 0.435, mse_score: 0.005)\n", + "15:39 madminer.utils.ml.tr INFO val. loss 0.44132 (improved_xe: 0.436, mse_score: 0.005)\n", + "15:39 madminer.utils.ml.tr INFO Epoch 20: train loss 0.43942 (improved_xe: 0.434, mse_score: 0.005)\n", + "15:39 madminer.utils.ml.tr INFO val. loss 0.44123 (improved_xe: 0.436, mse_score: 0.005)\n", + "15:39 madminer.utils.ml.tr INFO Early stopping did not improve performance\n" ] } ], "source": [ - "forge.train(\n", + "estimator.train(\n", " method='alices',\n", - " theta0_filename='data/samples/theta0_train.npy',\n", - " x_filename='data/samples/x_train.npy',\n", - " y_filename='data/samples/y_train.npy',\n", - " r_xz_filename='data/samples/r_xz_train.npy',\n", - " t_xz0_filename='data/samples/t_xz_train.npy',\n", - " n_hidden=(20,20),\n", - " alpha=10.,\n", + " theta='data/samples/theta0_train.npy',\n", + " x='data/samples/x_train.npy',\n", + " y='data/samples/y_train.npy',\n", + " r_xz='data/samples/r_xz_train.npy',\n", + " t_xz='data/samples/t_xz_train.npy',\n", + " alpha=1.,\n", " n_epochs=20,\n", ")\n", "\n", - "forge.save('models/alices')" + "estimator.save('models/alices')" ] }, { @@ -882,12 +1175,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "`forge.evaluate(theta,x)` estimated the log likelihood ratio and the score for all combination between the given phase-space points `x` and parameters `theta`. That is, if given 100 events `x` and a grid of 25 `theta` points, it will return 25\\*100 estimates for the log likelihood and 25\\*100 estimates for the score, both indexed by `[i_theta,i_x]`." + "`estimator.evaluate_log_likelihood_ratio(theta,x)` estimated the log likelihood ratio and the score for all combination between the given phase-space points `x` and parameters `theta`. That is, if given 100 events `x` and a grid of 25 `theta` points, it will return 25\\*100 estimates for the log likelihood ratio and 25\\*100 estimates for the score, both indexed by `[i_theta,i_x]`." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -902,14 +1195,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "forge.load('models/alices')\n", + "estimator.load('models/alices')\n", "\n", - "log_r_hat, _, _ = forge.evaluate(\n", - " theta0_filename='data/samples/theta_grid.npy',\n", + "log_r_hat, _ = estimator.evaluate_log_likelihood_ratio(\n", + " theta='data/samples/theta_grid.npy',\n", " x='data/samples/x_test.npy',\n", " evaluate_score=False\n", ")" @@ -924,12 +1217,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -971,8 +1264,296 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Note that in this tutorial our sample size was very small, and the network does not really have a chance to converge to the correct likelihood ratio function. So don't worry if you find a minimum that is not at the right point (the SM, i.e. the origin in this plot). Feel free to dial up the event numbers in the run card as well as the training samples and see what happens then!\n", + "Note that in this tutorial our sample size was very small, and the network might not really have a chance to converge to the correct likelihood ratio function. So don't worry if you find a minimum that is not at the right point (the SM, i.e. the origin in this plot). Feel free to dial up the event numbers in the run card as well as the training samples and see what happens then!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Limits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the end, what we care about are not plots of the log likelihood ratio, but limits on parameters. But at least under some asymptotic assumptions, these are directly related. MadMiner makes it easy to calculate p-values in the asymptotic limit with the `AsymptoticLimits` class in the `madminer.limits`: " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "15:39 madminer.analysis INFO Loading data from data/madminer_example_shuffled.h5\n", + "15:39 madminer.analysis INFO Found 2 parameters\n", + "15:39 madminer.analysis INFO Did not find nuisance parameters\n", + "15:39 madminer.analysis INFO Found 6 benchmarks, of which 6 physical\n", + "15:39 madminer.analysis INFO Found 2 observables\n", + "15:39 madminer.analysis INFO Found 6537 events\n", + "15:39 madminer.analysis INFO Found morphing setup with 6 components\n" + ] + } + ], + "source": [ + "limits = AsymptoticLimits('data/madminer_example_shuffled.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This class provids two high-level functions:\n", + "- `AsymptoticLimits.observed_limits()` lets us calculate p-values on a parameter grid for some observed events, and\n", + "- `AsymptoticLimits.expected_limits()` lets us calculate expected p-values on a parameter grid based on all data in the MadMiner file.\n", + "\n", + "Note that these limits include both rate and kinematic information (the neural network is used for the kinematic part).\n", + "\n", + "Let's try both:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "theta_min, theta_max = -20., 20.\n", + "resolution = 25" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Expected limits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, with `mode=\"rate\"`, we can calculate expected limits based only on rate information:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "expected_limits() got an unexpected keyword argument 'resolution'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"rate\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mresolution\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mresolution\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mluminosity\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m300000.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m )\n", + "\u001b[0;31mTypeError\u001b[0m: expected_limits() got an unexpected keyword argument 'resolution'" + ] + } + ], + "source": [ + "_, p_values_expected_xsec, best_fit_expected_xsec = limits.expected_limits(\n", + " theta_true=[0.,0.],\n", + " theta_ranges=[(theta_min, theta_max), (theta_min, theta_max)],\n", + " mode=\"rate\",\n", + " resolution=resolution,\n", + " luminosity=300000.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`mode=\"histo\"` calculates limits based on histograms. For now, there is not a lot of freedom in this step, the histogram binning is determined automatically." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "_, p_values_expected_histo, best_fit_expected_histo = limits.expected_limits(\n", + " theta_true=[0.,0.],\n", + " theta_ranges=[(theta_min, theta_max), (theta_min, theta_max)],\n", + " mode=\"histo\",\n", + " hist_vars=[\"pt_j1\"],\n", + " include_xsec=False,\n", + " resolution=resolution,\n", + " luminosity=300000.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally and perhaps most importantly, `mode=\"ml\"` allows us to calculate limits based on any `ParamterizedRatioEstimator` instance like the ALICES estimator trained above:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "theta_grid, p_values_expected_ml, best_fit_expected_ml = limits.expected_limits(\n", + " theta_true=[0.,0.],\n", + " theta_ranges=[(theta_min, theta_max), (theta_min, theta_max)],\n", + " mode=\"ml\",\n", + " model_file='models/alices',\n", + " include_xsec=False,\n", + " resolution=resolution,\n", + " luminosity=300000.0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Observed limits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Observed limits take as input actual data, which we here generate on the fly:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sampler = SampleAugmenter('data/madminer_example_shuffled.h5')\n", + "x_observed, _ = sampler.extract_samples_test(\n", + " theta=sampling.morphing_point([0.,0.]),\n", + " n_samples=5,\n", + " folder=None,\n", + " filename=None\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "_, p_values_observed, best_fit_observed = limits.observed_limits(\n", + " x_observed=x_observed,\n", + " theta_ranges=[(theta_min, theta_max), (theta_min, theta_max)],\n", + " mode=\"ml\",\n", + " model_file='models/alices',\n", + " include_xsec=True,\n", + " resolution=resolution,\n", + " luminosity=300000.0,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's plot the results:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "bin_size = (theta_max - theta_min)/(resolution - 1)\n", + "edges = np.linspace(theta_min - bin_size/2, theta_max + bin_size/2, resolution + 1)\n", + "centers = np.linspace(theta_min, theta_max, resolution)\n", + "\n", + "fig = plt.figure(figsize=(6,5))\n", + "ax = plt.gca()\n", "\n", + "cmin, cmax = 1.e-3, 1.\n", + " \n", + "pcm = ax.pcolormesh(\n", + " edges, edges, p_values_expected_ml.reshape((resolution, resolution)),\n", + " norm=matplotlib.colors.LogNorm(vmin=cmin, vmax=cmax),\n", + " cmap='Greys_r'\n", + ")\n", + "cbar = fig.colorbar(pcm, ax=ax, extend='both')\n", + "\n", + "plt.contour(\n", + " centers, centers, p_values_expected_xsec.reshape((resolution, resolution)),\n", + " levels=[0.05],\n", + " linestyles='-', colors='darkgreen'\n", + ")\n", + "plt.contour(\n", + " centers, centers, p_values_expected_ml.reshape((resolution, resolution)),\n", + " levels=[0.05],\n", + " linestyles='-', colors='#CC002E'\n", + ")\n", + "plt.contour(\n", + " centers, centers, p_values_expected_histo.reshape((resolution, resolution)),\n", + " levels=[0.05],\n", + " linestyles='-', colors='C1'\n", + ")\n", + "plt.contour(\n", + " centers, centers, p_values_observed.reshape((resolution, resolution)),\n", + " levels=[0.05],\n", + " linestyles='--', colors='black'\n", + ")\n", + "\n", + "plt.scatter(\n", + " theta_grid[best_fit_expected_xsec][0], theta_grid[best_fit_expected_xsec][1],\n", + " s=80., color='darkgreen', marker='*',\n", + " label=\"xsec\"\n", + ")\n", + "plt.scatter(\n", + " theta_grid[best_fit_expected_ml][0], theta_grid[best_fit_expected_ml][1],\n", + " s=80., color='#CC002E', marker='*',\n", + " label=\"ALICES\"\n", + ")\n", + "plt.scatter(\n", + " theta_grid[best_fit_expected_histo][0], theta_grid[best_fit_expected_histo][1],\n", + " s=80., color='C1', marker='*',\n", + " label=\"Histo\"\n", + ")\n", + "plt.scatter(\n", + " theta_grid[best_fit_observed][0], theta_grid[best_fit_observed][1],\n", + " s=80., color='black', marker='*',\n", + " label=\"Observed\"\n", + ")\n", + "\n", + "plt.legend()\n", + "\n", + "plt.xlabel(r'$\\theta_0$')\n", + "plt.ylabel(r'$\\theta_1$')\n", + "cbar.set_label('Expected p-value (ALICES)')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ "That's it for now. Please have a look at the documentation for a detailed description of all classes and functions. And if you're curious about SALLY, Fisher information matrices, and ensemble methods, please look at the second part of the tutorial!" ] }, diff --git a/examples/tutorial_parton_level/2_score_information_ensemble.ipynb b/examples/tutorial_parton_level/2_score_information_ensemble.ipynb index c2b9e544f..5fb3e7ff0 100755 --- a/examples/tutorial_parton_level/2_score_information_ensemble.ipynb +++ b/examples/tutorial_parton_level/2_score_information_ensemble.ipynb @@ -47,8 +47,9 @@ "from matplotlib import pyplot as plt\n", "%matplotlib inline\n", "\n", - "from madminer.sampling import SampleAugmenter, constant_benchmark_theta\n", - "from madminer.ml import MLForge, EnsembleForge\n", + "from madminer import sampling\n", + "from madminer.sampling import SampleAugmenter\n", + "from madminer.ml import ScoreEstimator, Ensemble\n", "from madminer.fisherinformation import FisherInformation\n", "from madminer.plotting import plot_fisher_information_contours_2d\n" ] @@ -116,25 +117,25 @@ "name": "stderr", "output_type": "stream", "text": [ - "11:50 madminer.sampling INFO Loading data from data/madminer_example_shuffled.h5\n", - "11:50 madminer.sampling INFO Found 2 parameters\n", - "11:50 madminer.sampling INFO Did not find nuisance parameters\n", - "11:50 madminer.sampling INFO Found 6 benchmarks, of which 6 physical\n", - "11:50 madminer.sampling INFO Found 2 observables\n", - "11:50 madminer.sampling INFO Found 6537 events\n", - "11:50 madminer.sampling INFO Found morphing setup with 6 components\n" + "15:36 madminer.analysis INFO Loading data from data/madminer_example_shuffled.h5\n", + "15:36 madminer.analysis INFO Found 2 parameters\n", + "15:36 madminer.analysis INFO Did not find nuisance parameters\n", + "15:36 madminer.analysis INFO Found 6 benchmarks, of which 6 physical\n", + "15:36 madminer.analysis INFO Found 2 observables\n", + "15:36 madminer.analysis INFO Found 6537 events\n", + "15:36 madminer.analysis INFO Found morphing setup with 6 components\n" ] } ], "source": [ - "sa = SampleAugmenter('data/madminer_example_shuffled.h5')" + "sampler = SampleAugmenter('data/madminer_example_shuffled.h5')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The relevant `SampleAugmenter` function for local score estimators is `extract_samples_train_local()`. As before, for the argument `theta` you can use the helper functions `constant_benchmark_theta()`, `multiple_benchmark_thetas()`, `constant_morphing_theta()`, `multiple_morphing_thetas()`, and `random_morphing_thetas()`." + "The relevant `SampleAugmenter` function for local score estimators is `extract_samples_train_local()`. As before, for the argument `theta` you can use the helper functions `sampling.benchmark()`, `sampling.benchmarks()`, `sampling.morphing_point()`, `sampling.morphing_points()`, and `sampling.random_morphing_points()`." ] }, { @@ -146,14 +147,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "11:50 madminer.sampling INFO Extracting training sample for local score regression. Sampling and score evaluation according to (u'benchmark', u'sm')\n", - "11:50 madminer.sampling INFO Effective number of samples: 3269.0000000001205\n" + "15:36 madminer.sampling INFO Extracting training sample for local score regression. Sampling and score evaluation according to (u'benchmark', u'sm')\n", + "15:36 madminer.sampling INFO Effective number of samples: 5230.0\n" ] } ], "source": [ - "x, theta, t_xz = sa.extract_samples_train_local(\n", - " theta=constant_benchmark_theta('sm'),\n", + "x, theta, t_xz, _ = sampler.sample_train_local(\n", + " theta=sampling.benchmark('sm'),\n", " n_samples=100000,\n", " folder='./data/samples',\n", " filename='train'\n", @@ -173,7 +174,7 @@ "source": [ "It's now time to build a neural network. Only this time, instead of the likelihood ratio itself, we will estimate the gradient of the log likelihood with respect to the theory parameters -- the score. To be precise, the output of the neural network is an estimate of the score at some reference parameter point, for instance the Standard Model. A neural network that estimates this \"local\" score can be used to calculate the Fisher information at that point. The estimated score can also be used as a machine learning version of Optimal Observables, and likelihoods can be estimated based on density estimation in the estimated score space. This method for likelihood ratio estimation is called SALLY, and there is a closely related version called SALLINO. Both are explained in [\"Constraining Effective Field Theories With Machine Learning\"](https://arxiv.org/abs/1805.00013) and [\"A Guide to Constraining Effective Field Theories With Machine Learning\"](https://arxiv.org/abs/1805.00020).\n", "\n", - "Again, the central object for this is the `madminer.ml.MLForge` class:" + "The central object for this is the `madminer.ml.ScoreEstimator` class:" ] }, { @@ -182,7 +183,7 @@ "metadata": {}, "outputs": [], "source": [ - "forge = MLForge()" + "estimator = ScoreEstimator(n_hidden=(20,))" ] }, { @@ -201,147 +202,65 @@ "name": "stderr", "output_type": "stream", "text": [ - "11:50 madminer.ml INFO Starting training\n", - "11:50 madminer.ml INFO Method: sally\n", - "11:50 madminer.ml INFO Training data: x at data/samples/x_train.npy\n", - "11:50 madminer.ml INFO t_xz (theta0) at data/samples/t_xz_train.npy\n", - "11:50 madminer.ml INFO Features: all\n", - "11:50 madminer.ml INFO Method: sally\n", - "11:50 madminer.ml INFO Hidden layers: (100, 100, 100)\n", - "11:50 madminer.ml INFO Activation function: tanh\n", - "11:50 madminer.ml INFO Batch size: 200\n", - "11:50 madminer.ml INFO Optimizer: amsgrad\n", - "11:50 madminer.ml INFO Epochs: 50\n", - "11:50 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "11:50 madminer.ml INFO Validation split: 0.25\n", - "11:50 madminer.ml INFO Early stopping: True\n", - "11:50 madminer.ml INFO Scale inputs: True\n", - "11:50 madminer.ml INFO Shuffle labels False\n", - "11:50 madminer.ml INFO Samples: all\n", - "11:50 madminer.ml INFO Loading training data\n", - "11:50 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", - "11:50 madminer.ml INFO Rescaling inputs\n", - "11:50 madminer.ml INFO Creating model for method sally\n", - "11:50 madminer.ml INFO Training model\n", - "11:50 madminer.utils.ml.tr INFO Epoch 1: train loss 0.12853 (mse_score: 0.129)\n", - "11:50 madminer.utils.ml.tr INFO val. loss 0.11797 (mse_score: 0.118)\n", - "11:50 madminer.utils.ml.tr INFO Epoch 2: train loss 0.10225 (mse_score: 0.102)\n", - "11:50 madminer.utils.ml.tr INFO val. loss 0.10731 (mse_score: 0.107)\n", - "11:50 madminer.utils.ml.tr INFO Epoch 3: train loss 0.09853 (mse_score: 0.099)\n", - "11:50 madminer.utils.ml.tr INFO val. loss 0.10433 (mse_score: 0.104)\n", - "11:50 madminer.utils.ml.tr INFO Epoch 4: train loss 0.09622 (mse_score: 0.096)\n", - "11:50 madminer.utils.ml.tr INFO val. loss 0.10161 (mse_score: 0.102)\n", - "11:51 madminer.utils.ml.tr INFO Epoch 5: train loss 0.09503 (mse_score: 0.095)\n", - "11:51 madminer.utils.ml.tr INFO val. loss 0.10109 (mse_score: 0.101)\n", - "11:51 madminer.utils.ml.tr INFO Epoch 6: train loss 0.09354 (mse_score: 0.094)\n", - "11:51 madminer.utils.ml.tr INFO val. loss 0.09757 (mse_score: 0.098)\n", - "11:51 madminer.utils.ml.tr INFO Epoch 7: train loss 0.09216 (mse_score: 0.092)\n", - "11:51 madminer.utils.ml.tr INFO val. loss 0.09496 (mse_score: 0.095)\n", - "11:51 madminer.utils.ml.tr INFO Epoch 8: train loss 0.09107 (mse_score: 0.091)\n", - "11:51 madminer.utils.ml.tr INFO val. loss 0.09510 (mse_score: 0.095)\n", - "11:51 madminer.utils.ml.tr INFO Epoch 9: train loss 0.09009 (mse_score: 0.090)\n", - "11:51 madminer.utils.ml.tr INFO val. loss 0.09363 (mse_score: 0.094)\n", - "11:51 madminer.utils.ml.tr INFO Epoch 10: train loss 0.08897 (mse_score: 0.089)\n", - "11:51 madminer.utils.ml.tr INFO val. loss 0.08927 (mse_score: 0.089)\n", - "11:51 madminer.utils.ml.tr INFO Epoch 11: train loss 0.08778 (mse_score: 0.088)\n", - "11:51 madminer.utils.ml.tr INFO val. loss 0.08908 (mse_score: 0.089)\n", - "11:51 madminer.utils.ml.tr INFO Epoch 12: train loss 0.08711 (mse_score: 0.087)\n", - "11:51 madminer.utils.ml.tr INFO val. loss 0.08946 (mse_score: 0.089)\n", - "11:51 madminer.utils.ml.tr INFO Epoch 13: train loss 0.08582 (mse_score: 0.086)\n", - "11:51 madminer.utils.ml.tr INFO val. loss 0.08651 (mse_score: 0.087)\n", - "11:51 madminer.utils.ml.tr INFO Epoch 14: train loss 0.08540 (mse_score: 0.085)\n", - "11:51 madminer.utils.ml.tr INFO val. loss 0.08647 (mse_score: 0.086)\n", - "11:51 madminer.utils.ml.tr INFO Epoch 15: train loss 0.08405 (mse_score: 0.084)\n", - "11:51 madminer.utils.ml.tr INFO val. loss 0.08439 (mse_score: 0.084)\n", - "11:51 madminer.utils.ml.tr INFO Epoch 16: train loss 0.08389 (mse_score: 0.084)\n", - "11:51 madminer.utils.ml.tr INFO val. loss 0.08511 (mse_score: 0.085)\n", - "11:51 madminer.utils.ml.tr INFO Epoch 17: train loss 0.08320 (mse_score: 0.083)\n", - "11:51 madminer.utils.ml.tr INFO val. loss 0.08306 (mse_score: 0.083)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 18: train loss 0.08241 (mse_score: 0.082)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.08270 (mse_score: 0.083)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 19: train loss 0.08198 (mse_score: 0.082)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.08095 (mse_score: 0.081)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 20: train loss 0.08147 (mse_score: 0.081)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07968 (mse_score: 0.080)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 21: train loss 0.08086 (mse_score: 0.081)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.08142 (mse_score: 0.081)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 22: train loss 0.08046 (mse_score: 0.080)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07964 (mse_score: 0.080)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 23: train loss 0.08013 (mse_score: 0.080)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.08024 (mse_score: 0.080)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 24: train loss 0.07960 (mse_score: 0.080)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07819 (mse_score: 0.078)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 25: train loss 0.07921 (mse_score: 0.079)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07826 (mse_score: 0.078)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 26: train loss 0.07909 (mse_score: 0.079)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07719 (mse_score: 0.077)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 27: train loss 0.07860 (mse_score: 0.079)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07716 (mse_score: 0.077)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 28: train loss 0.07844 (mse_score: 0.078)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07652 (mse_score: 0.077)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 29: train loss 0.07827 (mse_score: 0.078)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07640 (mse_score: 0.076)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 30: train loss 0.07796 (mse_score: 0.078)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07635 (mse_score: 0.076)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 31: train loss 0.07773 (mse_score: 0.078)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07553 (mse_score: 0.076)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 32: train loss 0.07738 (mse_score: 0.077)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07580 (mse_score: 0.076)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 33: train loss 0.07736 (mse_score: 0.077)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07492 (mse_score: 0.075)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 34: train loss 0.07709 (mse_score: 0.077)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07560 (mse_score: 0.076)\n", - "11:52 madminer.utils.ml.tr INFO Epoch 35: train loss 0.07690 (mse_score: 0.077)\n", - "11:52 madminer.utils.ml.tr INFO val. loss 0.07532 (mse_score: 0.075)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 36: train loss 0.07680 (mse_score: 0.077)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07509 (mse_score: 0.075)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 37: train loss 0.07666 (mse_score: 0.077)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07478 (mse_score: 0.075)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 38: train loss 0.07642 (mse_score: 0.076)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07495 (mse_score: 0.075)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 39: train loss 0.07639 (mse_score: 0.076)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07424 (mse_score: 0.074)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "11:53 madminer.utils.ml.tr INFO Epoch 40: train loss 0.07616 (mse_score: 0.076)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07436 (mse_score: 0.074)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 41: train loss 0.07610 (mse_score: 0.076)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07434 (mse_score: 0.074)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 42: train loss 0.07597 (mse_score: 0.076)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07398 (mse_score: 0.074)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 43: train loss 0.07590 (mse_score: 0.076)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07410 (mse_score: 0.074)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 44: train loss 0.07574 (mse_score: 0.076)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07400 (mse_score: 0.074)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 45: train loss 0.07568 (mse_score: 0.076)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07379 (mse_score: 0.074)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 46: train loss 0.07557 (mse_score: 0.076)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07363 (mse_score: 0.074)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 47: train loss 0.07560 (mse_score: 0.076)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07369 (mse_score: 0.074)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 48: train loss 0.07534 (mse_score: 0.075)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07333 (mse_score: 0.073)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 49: train loss 0.07528 (mse_score: 0.075)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07339 (mse_score: 0.073)\n", - "11:53 madminer.utils.ml.tr INFO Epoch 50: train loss 0.07520 (mse_score: 0.075)\n", - "11:53 madminer.utils.ml.tr INFO val. loss 0.07348 (mse_score: 0.073)\n", - "11:53 madminer.utils.ml.tr INFO Early stopping did not improve performance\n" + "15:36 madminer.ml INFO Starting training\n", + "15:36 madminer.ml INFO Batch size: 200\n", + "15:36 madminer.ml INFO Optimizer: amsgrad\n", + "15:36 madminer.ml INFO Epochs: 50\n", + "15:36 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", + "15:36 madminer.ml INFO Validation split: 0.25\n", + "15:36 madminer.ml INFO Early stopping: True\n", + "15:36 madminer.ml INFO Scale inputs: True\n", + "15:36 madminer.ml INFO Shuffle labels False\n", + "15:36 madminer.ml INFO Samples: all\n", + "15:36 madminer.ml INFO Loading training data\n", + "15:36 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", + "15:36 madminer.ml INFO Rescaling inputs\n", + "15:36 madminer.ml INFO Creating model\n", + "15:36 madminer.ml INFO Training model\n", + "15:36 madminer.utils.ml.tr INFO Epoch 3: train loss 0.19037 (mse_score: 0.190)\n", + "15:36 madminer.utils.ml.tr INFO val. loss 0.15904 (mse_score: 0.159)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 6: train loss 0.14389 (mse_score: 0.144)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.12421 (mse_score: 0.124)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 9: train loss 0.12970 (mse_score: 0.130)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.11444 (mse_score: 0.114)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 12: train loss 0.12303 (mse_score: 0.123)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.10981 (mse_score: 0.110)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 15: train loss 0.11926 (mse_score: 0.119)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.10723 (mse_score: 0.107)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 18: train loss 0.11690 (mse_score: 0.117)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.10569 (mse_score: 0.106)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 21: train loss 0.11537 (mse_score: 0.115)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.10467 (mse_score: 0.105)\n", + "15:37 madminer.utils.ml.tr INFO Epoch 24: train loss 0.11426 (mse_score: 0.114)\n", + "15:37 madminer.utils.ml.tr INFO val. loss 0.10407 (mse_score: 0.104)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 27: train loss 0.11342 (mse_score: 0.113)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.10358 (mse_score: 0.104)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 30: train loss 0.11283 (mse_score: 0.113)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.10306 (mse_score: 0.103)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 33: train loss 0.11231 (mse_score: 0.112)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.10260 (mse_score: 0.103)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 36: train loss 0.11192 (mse_score: 0.112)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.10236 (mse_score: 0.102)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 39: train loss 0.11158 (mse_score: 0.112)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.10215 (mse_score: 0.102)\n", + "15:38 madminer.utils.ml.tr INFO Epoch 42: train loss 0.11129 (mse_score: 0.111)\n", + "15:38 madminer.utils.ml.tr INFO val. loss 0.10194 (mse_score: 0.102)\n", + "15:39 madminer.utils.ml.tr INFO Epoch 45: train loss 0.11106 (mse_score: 0.111)\n", + "15:39 madminer.utils.ml.tr INFO val. loss 0.10175 (mse_score: 0.102)\n", + "15:39 madminer.utils.ml.tr INFO Epoch 48: train loss 0.11085 (mse_score: 0.111)\n", + "15:39 madminer.utils.ml.tr INFO val. loss 0.10162 (mse_score: 0.102)\n", + "15:39 madminer.utils.ml.tr INFO Early stopping did not improve performance\n" ] } ], "source": [ - "forge.train(\n", + "estimator.train(\n", " method='sally',\n", - " x_filename='data/samples/x_train.npy',\n", - " t_xz0_filename='data/samples/t_xz_train.npy',\n", - " verbose=\"all\",\n", + " x='data/samples/x_train.npy',\n", + " t_xz='data/samples/t_xz_train.npy',\n", ")\n", "\n", - "forge.save('models/sally')" + "estimator.save('models/sally')" ] }, { @@ -364,9 +283,9 @@ "metadata": {}, "outputs": [], "source": [ - "forge.load('models/sally')\n", + "estimator.load('models/sally')\n", "\n", - "t_hat = forge.evaluate(\n", + "t_hat = estimator.evaluate_score(\n", " x='data/samples/x_test.npy'\n", ")" ] @@ -385,7 +304,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsUAAAEYCAYAAAC0g4t0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsnXW8FFX/x99nZndvw6UFaURJRUQFbBRFsbs7sFAeseMxHvXRn10PIgZ2YQEqikqpSCil0t1xO3Z34vz+OJM34IKAyN0Pr+XuzJya2d3vfOZ7Pt/vEVJKUkghhRRSSCGFFFJIoTZD+7sHkEIKKaSQQgoppJBCCn83UqQ4hRRSSCGFFFJIIYVajxQpTiGFFFJIIYUUUkih1iNFilNIIYUUUkghhRRSqPVIkeIUUkghhRRSSCGFFGo9UqQ4hRRSSCGFFFJIIYVajxQpTiGFFP6REEL0E0LME0IsFELcsZlyZwohpBCix84cXwoppJBCbcDuZItTpDiFFFL4x0EIoQMvAscDnYDzhBCdqiiXAwwEftm5I0whhRRS2P2xu9niFClOIYUU/ok4CFgopVwspUwC7wOnVFHuIeBxIL4zB5dCCimkUEuwW9niyN89gL+Chg0bytatW9eorCXLKDMWe9uCNCSJSuX8Bf4EIBHoSOxq261uPcDMaEtKjRVVlBWhfREtB4FOwi4kuLigEBq5sdboIlZt35vD6vKlSCwkIBAIdCxpecebZrQgIqKV6hm2QdxKkBnJQBf6NvUdRImRYFnpptA+Kf1roAuNjrlNvO24aZKwTOqmpW+23dnr1oW2W+XmUictreoxxBMs21TgbcciOu2bNKzxOfwVlJclWbtiE1JCo6a55NTN2Cn97khMnz59o5Sy0dbWO+6oLLkpz9pyQWD6rMTvhI3nUCnl0MD2nkDwB7YSODjYhhBif6CFlHKUEGLw1o43hZpja2zx8tL1lNtJb1tIgV2tJa0IZZfBt6euNZH+zhBaZjZgWdmmSvuD9QSC3GgWhUZZaCwCyIzEaJW1bfai1IyzqjwPW9rO3UTDwvb6jmkR2mY3qbJusVEOQE50+9iMlWUrMaXpbQs05w6h0CBWj7rROn7/ZhkxLUKaVv09qMgoZmMyL7BH0DarZbXlFxWvJ2H7Y2iRWZ+c6OZt/fbCmrxiikrLiUZ0WjWpj66JLVfaxZGyxdsf/2hS3Lp1a6ZNm1ajsj+tOIa4teUvgSUFYXMJIBxaXPlHZAMy4HCX0jWydTHJCO030Lw2VDmBLQU2GiYtsKTuHY+IdHo1/hft654Q6m/E0ttZXv4bAsHxze5gn7pHVXkej/15LXnJDd4ZSCmwpMBCEd0TmpzNcc1OC9WZsOFn/rfodedMBY92vYdWWS2qvVY1wXtLpvDQzC+9bdsGywp/7aaddQ8AAyd8wRdL/gSgQGjMPvcmMmIxjnjnFZYVFwLQq1kL3jv5HNo+81SojasPPIjBhxxa5RiueeNTJs5fGu7zkUF/6bxqihO73kPLFv5D1Qdj76FObuZO6XtHQQixbFvqbcqzmDKm+htmEHrTBXEp5eZ0Z1Xd0fxHWiE04Gng0q0ZYwrbhq2xxYd/d6v33rLB/SiFIOQYcPeB2m/ZmndcSuF92LrmV7LsoP1WMCyNvQO7BBIhKrYtMC2NXARgE9H945oQTDvhwVCbq0sL6f/di8QtgwZpWXx/3CBiemUnwoLi1Vw2+TkSpiBpufZdkhax0Bx+P7nfo5XqnTfxORaWrAWgdVYjPjr8r9ur66bfSKlV5m0btgjdu3Ii2Qzt8RRJK8lpP95JA8eJ0qt+F+7veiUrSzZy/i+PeeVf6H4tEzdOYMLGyaF+Pug1pNox7DfyvtBzy4EN2vBq78v+4pltGSMmzuLhd77DffzYq1kDPrzv4h3e745GyhZvf9Qa+UREz93scdfYKlPrvtSeQKlwHXyfRUVjblJcZR/uy+vTaV73WlM0WyJpkL5PqP68wvEsL/8NCVhIRq5+lB/WDqXMLGJTYpVXbk3JEoqN9aFzEAI04Q/yl/xxobZXlq5i+JJ3AMs9Iz5c+QUAG+MFnDzhZvpPGEj/CQOZV7S00rlVh7NbHkBU+F+zBtHqCaFLiAFMafPEzIkMnz3NI8QAP69egWmaNM/JCdW9ovsB1bZ7+N5tQtvZaZU95DsCtm1jWeFZhlVLNu6UvndFqG93zf7VACuB4BNbc2B1YDsH6AKME0IsBXoCX+zKAR4pVIZrL20Jhq1hOrNMtvRnnCzbsdqeeZNeXdMKztD5DgnLDthj57iUAiRYlq7KWALbhn1y9qg0rvPGD6PcNJAS1pWWse+nj7K2rJDFRZsoSvpOtRfn/EhRWQTT8h0i3pglmLZgYzx8r3hn4RT+KFjrbS8t3cCGeBEAT/0xhv1G3ct+o+7lhO/CjoEt4ewWZ4a2y410VpXksKEsE1tCw1h9AN5dNhYzMKv4c94cAC6d8nSo/i2/DeOs5ieG9rXO3LwTpU4Fr/chjfbaqnPYVsxatCa0vXpT0U7pd1dFyhZXj13KUyyESAcmAGmosX0spfz39mi7e+O3mbDyAMCfupEy7J0IEmP1VpG5qib2XPoKAlv6O939yglgI6Vqw/JaBs84uq4IJDYi6G/GkuV8suxymmccweKyiQBEhTJawa/plLwRTM77DIDsSAOKEgniJBFABIHheIZdz7SL8oDH4MPlIxi99kukhKgAQ1qARj1nKu3+OUOwAr3eP+dl3utd2btRFXRdZ+qJd/HW4sk0Sa/DfdPHhI7f1qVPpTrSuYivzf4V2/YFIEFMuOIqHps4geWFhdx75JHUy6h+ivGC3t34fdVaPv/1T+rnZPLJDRfUaOx/FZqm0aBxDpvWq5teWnqU9l2b7ZS+d01ILFkjI1sTTAXaCyHaAKuAc4HzvZ6kLAS8OW8hxDhgsJSyZu7MWowdaYcBrml3Ai8vUrNH6VqEuO08iDt21JaOhRQuIRaYtksqBaZtY9rKrgkkupAkTN2lvOiajRCQNDUsW0fXbDRNeoK4eDKCpql6mmaDAMshrRKwLCi3fMnAlNV5HDv6f6wuL6bcMgDIiKnvsWkqq23YkkNGPo9r23s0aMH0jctRvD2NWMwkGrGd+40ixIalYVga84vW0TBdPeTv//ljlJpJIJ3ypCQrLUlEl+RElMRg+OJJ3rhWlefz2fJfObVl9xpd9yMbH0HbrLZMy59OpmjG3bM+B6AMiWlHeOdAlTQgN5bl1TEtwfriHDp+8iDRiEadDNCcG5UlbRpnNOTpbg/w/rLPaJG5J2e1PLFSv0F8fuSNnPbdi+Qb5fRr3onL2x9Wo7H/VZx5+L6MnPyHt933gL13Sr+7LlK2uDrsUqQYSAB9pJQlQogoMEkI8ZWUcvKWKm4JkUg6fVr/7m1vKJnErA1XKKMLBLVqLhl2yW1F+CQ5SGPDhDdIpE1A4k6thY/7fwVC+K5jTaonueVlP+B+THErD9ARagIQJevwx1BsbCJBRI1LCDQBEdvGREMIHdP2z+bYJqd6779c+1XoASECpOkZXNr6PADKzXhgpAIzoAmrCWJ6hCvaK2nDoMlfhI41zvQ9vrd1P5zHf53gXJCAzlCXYKmxN8zIJBJR1+P2ww6vUf8X/+8Dpi9VD655hWXU2UmeYoDXvrmV15/8mnjc4LJBx3ljr42QgEnNdGxbbEtKUwhxAzAG0IHXpJS/CyEeBKZJKb/YfAspbAY7zA4DXND6KC5o7cu+Lv7pGRaWrFbeWamh7KprfQWWdImkspGW7dtSCY5d07ClIrRJoo6jQtkM09IcYmxjmjoIDdu2EZrAtsKTpcoDrWQOrj0UAhYW5xGQ41JmC5A6CHAnwtT41PupG1cEJBoCw9BBgh6x0RAYVhR3hL0bK2/pypIChxA75yYFRaXpXNPpANIjiqTbliLwesRG06Aw6Ts3aoKWWS1omdWCF+d94+2TCMrMDM82ndr8CEas/IH1iQLySjMxrQgSSJoRkmaEtKiJAAbs3R+AZhlN+FeHa2rUf88nXgFiQIypy4tgJ/kKu7Ztyuu3ncNH42exb5s9OPvIbjun410UKVtcPXapO7SUUgIlzmbUedU0AmOroGvpIUKpUJkC17xzUWkrIF4ICTKCxyt6cKuDa+QjzoSGRCMp3fH7ZDrYL1KiCYiSRULGiQiJlBoNYk3o2dD30GpoyOAPREBmJJ2IFsEwDNYbmwIqa8n17c/Z4nirQ/PMuqwsK3T6FRzWpJ137Lquvbiuay/GrVzMdd99TqlpVPpIpl1yXbVtT1i4mI9n/M6AQw6iU1M/eMUlxC5OfOotvr3zym0+h61BLBbhmjs37z2pLZBIrIo6o7/SnpRfAl9W2HdfNWWP3G4d7+bYmXYYoChpkLQiigJ7M3calu2QZCkD2lfXeeCOVWDZygEAjnPCI8RuYwLL1n0yLVVcgy0sdD2sR7ZtgTQFWuDOKH1DjrQUAfedbFI9tCMRWmDyL1DXJcaWESNeFPHmITMigovaH+SVzY5UDjjTNY0maSqO6vHpP1Bc6MvPcusmuLBNr+ov7GZwXLP9eG3xeG+7U509Q8ff6nk/AJdNfIufNyzx9hfHo5gWHFy/I2e3rN7L+/i3E4ibJvcd799nBn8a+qmyqqiyxHBHYr+2zdivbW2eqfORssXVY5cixeDlvJsO7AW8KKX8pcLxq4GrAVq2rJlQvCKWFQ5nft7j1R4Pf1XCMcruMduhn8GAj2ANWamuhGCgHRJLgo0Wqu9+Ty0Z0CxLG9D8wA8JSefGoTnjst0Y6qAeRMA+mQcxs2SG2hQAFusSa7lt5uUYMkKOVofr2lzD80te8qppQmev7HbcOfNJ/iha7LfrnMqRTbb98f6r467l/t++Ii9RxuCuR1I/vbLG+JBmrehYvzG/b1pH3DKRtvLAvNP/rGrbvf3zMXw2S02PjflzIQ/2P5pzuu9bZdmkuX2ekFPYetQ8y0AKfye2ZIedMn/JFpeaCa6e/DrLSwvQhHrwt2Tw8VtzdMPuPl8T7MKWYNtCyc9EFXN7QoQMunSNqgRbRrAdbbGdDDtIhGaBpkyvN5tnaIHJQcfKS4FMqDEq1ZdERG2EJhFOXJ0ixoIMI5MkSVVWQlkSXp4zlaEzpyGk4KJO3di3blNmFa5RY7IhQ4tSR8+g02vPUKbF1fkIdX3KijPRqwjuqwn2ymnC0IOuZPjiCbTMasC/OpxQZblBnfswa9JbmLZNwjYAjbp6Q/7Xu/ogtU4PPeMRrnenzmTufSpIsChROdtTCn8fUra4auxypFhKaQHdhBC5wKdCiC5SyjmB40OBoQA9evTY6k81aeWzIO8p2IKAPJz4xzfMvtQiKINwCLL33h1rsI63FxyFrJuYJyiHcDmtjebU06r0I7tZJFwvtKvBO6v5bWxMrKJH/X5kRerwzZoR4JBi79wC7uRiu4gPVr7G8INeZUHxIr5YNYYlZSuYU7iYDYkiKsZiCqECyK6Z+gwLSlaTrsV4occN7JVTsyfw9EiE/x540mbLRDWdj048n6VF+TRIz9xiejbAI8QuHv1mvEeKm9evy8o8P1jv3evPq9FYq8PaNYU0aJhJNLrzZBi7AySEUkClsOtiS3bYKfOXbPEHSyfzZ8EqLESADLtw5RJhEiwdEmxZSpvgPqxLKauY+ZMBr7ETYJcUBDNNSknA6xsIhEtGvDYQePItlH/COyQtAVL4VaVAlmvUjaVxdbceNM+qyymtuwCwz5tPBCf1Arxagi14848ZvHXCmfTesyXD5k3my0XzKSwwGfzNGCzdVqoD/H5iWoTpa1ZzwWcfkbRMejTdkw/POHczVzyMAxq04YAGbTZbZt/6ezL++EGsjxfTMqs+Ea3iNQ5jXWFRyAMpgQkLFnN4+7Y8f9oJdP2/l7xjmX9RSmYYBnlrC2nSYuek19ydkLLF1WOXI8UupJQFjiC7HzBnC8W3AjaSqjWxrm0MSRDwPbYyRHj9Y1RxzHaDNgDXiqoAPrd1QZBc+62JQHtOPeF3KKXArKaelLCufAl99rjQO3J4o/58s/7DUBCLG83tothWkbjtc9oxPf93LCylLRaQFBLheq2lIF2P8dbSsSwoUZKEuJ3kjhnD+PiwKmdKthmaELStW7/m5Qk/fKQHDO6Y2y/nlwXLmDR/KTcc05O0QD7jt8ZMY/7y9ZzXtzudWqsoc8uyuOyWt1iyciO5dTJ577nLyM7OwDAMjj/uCe9aduvWkief3jlBe7sLUt6JfxZ2nB0GQ9peALLTGyBwM2fqesDOOjbItsC0I15xIaUXvGaaAiGU1taVpSnSK7AtgTSdmTpTQkQF34FwJBFVnbxjhy0RkEUo77Bnq6sJPClMJDm91b40zfZjJq7qfCAvzJrs8WzKBDKGItxOc+/+MZPDWrSmschl1pJNTo8SkRCIkigyaiOzLRBwY6feXDHqExKWup9NXbOKt2fP4MKu21cvmx1NIztadQ74isjJrBzwvEcdFbCdlpbG/HsGMWTiZNo2rM+xHf1gt00bihg+ZBzZOelcfsMxRCLq3jd76hLuuewVTMPimNMPYNCjZwMwYshYht3/iVf/fz/cTeuOYQlICptHyhZXjV0qJZsQopHjmUAIkQEcA8zdnn3E9AbkplWO1vUJVUX9rwgQYv8lvTpaiDRLBBYaEuF4gjVlRwPTgjauLXXTr+H16Af+Oftk2NthIrHQA0IOVd8luZM2vs8XK1/0WkiPpPOfzsOxpLoX2GhYUmCiK++KhPp6AwBKkuVY7m0q4PwQQni+8KRtsSHhe10ByqwdMy32zZIFvDnnN+LmlgP7Xj0/nHP586vCZPXg9q24pf8RIUJ8+0sjefbDCXw1eS4XP/Qu81dsAODfT41i8YqNSAn5hWVcdutbADz8n5Ehr9WMGcu39dRqJSRgSVmjVwp/H3aGHQY4u5XS01qWSpFmWYoQ21LDlhqGqWNaYJpCvTcjPiEOOA+U51gF6Nl2BCOpYxo6lqFjJSPYZgTp5QgWIDVIRrDLday4hrQdb29AWuGlanMIupe+rVyDYg1KdKW6tsP1sJ15QAm9Xx/K2hJfNzv4gCNoLupCXECJhjA19CIdvVhDKxGQgAHdDgRg2G/T/c8DxyuOQBgaWn4ULT/G76s3UV7BNq4p3f463aKyOO+M/43J87Zs7zKjUTo3bextt6pXl70rLJQ04LCeIUIcjye5+JTnGPPFb4x452euOON579gdFw4hmTCxbck3H0/jl+/VjOCwBz4JtXnbaeF0cSlsHilbXD12NU9xU2C4o2fTgA+llKO2V+O2bVOYmEGnBg/w0+r+FY6Kat5XDfVVcT3AQe9uFXBJpfTFE0ozXPmZRBLBRjoaO4lBMMG6IAJqRSSh3CE2Aluq+UBTalhS45e8MfySNxaBzunNr6N7/T6hvixH2+zKKDaahRQli8jSsyoOp9K1sKXkmzVTCHq1L21zLKvL8hg49Q0StsG9Xc/gpl8+pMQhy9fvfRQDOhy52etZEZd/9QnfL1MrED7+y0R+veQ6Rs6bx7Dp0zi5QweuPSi0YA6927Vm3r1bl+B+4szFoe2HhnzNogXrwfYfgQA25ZcCYFahRR47eiYtWjdkn84pL0VNsN2SAKWwI7FD7TBAXqKUhUXrOWGP/fh85WzPC6GFZtJASj2kK3b1ueq9qFL6IG0NoQlkSHcR6NyVZEhNkWFLyS9UFgnlxhVOHIXtdmqDiLsjVAJoiY6wK/ShdHEqf4cJh7zwChqCBpkZTLz2CoTUEIbmEWfc85GgxwUvjJvCK+ecSo+mzfhj43q/XekO3XeH/LZ8NXaBDdmq35iuc1W3HrwybgpvT55Bqwa5XNRzPwZ+qOKfIppg6t03kB6r+W0/v6SMvv9+BcPJt37Ooftx15l9uOv5kaxaX8h/ru9Piz3qhep8ctXWzZ7NnLoE0/Bt69qVeZzb9kby1xUi9miMCEg2Zk1ZzMF9OoU/T8AwTMa+PYED+3WjbsM6pLBlpGxx1RDyH/wk0KNHD1nTVZRsO8mE5UdgyIJKx3ybU4EAUpHo+jmJ/fLh1e7cFfGUXkfzfrxuO9LxLLtBdp4HWPrHTBkDbJXcHaGMrztWiePlFY7HOcPJ86l5bdjSv4FIBAYRTFv37EjC9lfOk1KR5L6Nj+OcluczacMvDFn0FhJJ3NQw8RcmESJK0hLELeHtu6H9yZzZ8gh6fnW3r1GSEDfd+6nC7JMfqPJzqQ6thzzhfwhAnz3bMG7xMu/4Ua1b8+ppp29Vm0H85/Vv+HziHN+2Skm01LkqtpKMgNo+7ohO3DvwBAzDoN+xT3htaECmKZFScvPdJ9Hn+KoD+3Y3CCGmb2GFoyqx735ROfrLmun/WjZfu019pPD3YGts8ZhVvzNo6kdVHpPOrFoww4TleGNt29EQB3TG0kalVXNy/xKYVVNReIAzK0ZASyxsAGeFPEMggrdBG0ezKzAM/4DbdDDoWLjENqHeW+l4BNfrC0XQha0orZnt6Ccs9QoSZM0SLLhTPdyfO+IDpq1ZRXY0SlFp0jsvAaRFIpiFJpotkMJGj+pMueU6xs5ZyF0jwrngZcD30nGPRnxy/YXUFC999RMvj/kFbBu9HERMIzuuEU/6JHb0s1fSsP62EdGSwlKuPOAu8tcXQVoMWjeD9Ztgo7pPi5xsyM7yrvnw8XfSuFk9Xn/4Uz58/lu/odIiIgIystIZ9vvT1KmfU1V3ux1Stnj7Y5eST+xIrCh+H0MWeNKFmjwKVPT8ejq1gB8xSI5BONpWhxA7017B2TW3kh1o25YqcM5GTRsKLK9uJFDXX33JradhyyQRYaPyT7jR2mpMruwBQBc23ev05oQ9zsZ2biDB1ZzqxtTTfqaexRGNevJ0twf4oOfT7J/bgXZZzbmjw5U8u/+tJC1f5xxMPxQU7btn/1cQ1TSV4Nn5wH5YvtQTmgD8sHTpNrf97ZR5fD5RySPdT+6Y7u39T0QTSAEd2zVmwAWHce9AFZkdjUb57oc7eeCh07nswt5kGDbx8iSJuMHIj6Zu83hqC6QEo4avFHZfPDzrK2zbyRphh3XDLvzV6sC2BLat5BFuVgbbEtimhrQdb68v9lIvCcoK6V6KNyw8e+IR4hCRdjTClvprGBKkI1uQwiG1FeQS7pglYAv0coGWcMmrv+iQS+aRgkix4Mr9uzPowF4IU3htCMs/C9M0OSyrOXd0PJQZ19zI22ecSYeGDem/9958cM453HJgbzQn77yQGhiQHYvx2a9+Ln53WEEUxuNsDVo2qge2TcYGiJVALM8mXhaWbDw+/IetajOIAQffS8H6InX1E0nSCwrJ9HI1gywuQeYX0PWgtvxv9CAaN1P3qcvuPo335zzKrS9eQoNsMEsTxEsSJMqSzJ7wZzW9peAiZYurx64mn9hhiGjZFXTDFTwAwek3gqQ1QF5Dk+oyQJDDcCcAvW3h585UntmK/fmk2pU0yEA70ivje6JtNccXqCmdqTjp3FBkgCArzCieRL/081GJ7u1gTTpnd+G5Ba/y40ZF7saun8QDnQZzf5cbQm30b3owI9eoHP7pWowTmikZg4a/2IYQ4amZLnW3PjfkkONO4cqRnwUuYvh4dAtR0JvD5DlLK+37z7UncPjEZ/3udMGwx6tOO3ToofuQm53Oh6+r1aWiMZ027RtXWTaFIARWDaRJKezeUMu+B+2rrECMHTtpCW/RDh+uRzhgi4XyGGNroXKqwWDPmuddkO5CSRUVUS7RdK1voGsByCQIpxnXKSAMh/wKVOBfVd9xKZ0xq7G//+0s9mnSkFgRnufbjgra5eYCcODdL2I6koVXvpvCL4/cwJcX+/aoS5MmvDRuMqVJtcLeyft2AOC4ru2ZsmSlVy49onsrBgI8fka/ymPbDE7s0ZE3PvmZlRvyK3xiPvZtv+25f/PXh+NTmjbI4uALe/H+4yO9ffv3asd/3xlQqW7dhnXpc8bBTHxvIptW5mMmTSzLotlelZflTqEiUra4OtQaUpwbPbjCnsr5hSFIWP2fflhh4tLVoGFw9WsiTKildAyecFrMIk7cI7m+kak8kqADAi8XsqpjOF5op0vnJiE9b3FwjAkZIWjZR69TAQrCWYZJZaIQPPTnoxSZKq+F5dyIHp77Iq8e+Bgxzc8F9K+OZ3H0Ht1ZWb6Roxvv76209O6hA7lhymskbZM7upxKr0btGTJ3PPvWa86xe3au4kqHsaG8lIRl0jy7LgBHt2pHVNMw7OCjjI8vL6j5FGBFnH/sAXwxyfeoNK6XTSQS4Yuh1/Cv/4xA0zWeu7f6nMgAXbq14trBxzN6xFTa7dOUqwcdt83jqS2QhLOepFA70Si9LqvKinF/0cpbHJAbCIgJjTKPSAZ/+dI1q2HYYYcF4MgTnH0uD3cIdbadRkncwNNN6H7VoGUOmWYLNKme+IUy9IhgOjZviAGHi3DK2L6nQBhgWjZz12zwPM9CgpaAFasK6DHoGWzTt+TlCYNPJ83mtEO7eu2mRyL8eOsAvpw9j+b16nBQ6xYAnHdwN1ZsKuTjaXNompvD+wPOZfaqdYz9cxGX9z6APXI3LyuwLJs1awqoVy+LrCwVlHx1/178+wV/XYZYRCPhXJg9GmRz4YkHbrbNzWH/Pp2Z9s1sb/vU6/rS7+LDyamXxaih39Pj2K7c8NQlm23jlmHX8sKNr7Ji/mrOvuVk2nTZtvULahNStrh61BpN8YrCT/kj7+5qj7tXoSoPsSszkCEyXEFG4ZSxKux3j4FLUF0JRrgPw1veVCWVNx0LKm1BMvDsYkrhyCQ0h4Cr9iwpsJ2pQhuNS1rfz8uLnsTEn4oCQUxkkm9YoZRycUvDIoJtC0zn7uH+YOpEchh+cPULndQEo5bNYdL6xQzufAwNMysv1jH8j195eKqagju9XWf+e6jyZny3ZBHXfz0Sw7Y5t1NXHj6q718aRxC/zVvJMx+Op3njXB68st82J8GvDrZt88zAN/nuo8k0bl6fR0YMomnrRtu1j78L26pj67JvTH44umbXoHPL1bVKx/ZPx9bY4h4jH6PYSIQIp3r29UmtbQtfDBsgnVKCWmVe+MsrmxBcGEkVcrzA0p0Nkz4pToCQARYcQNDLKwBp4M0f/NyLAAAgAElEQVTeaUlFbGUEhO26HnyPtJAgTOevY5zT0yK8eu5pXPzSR656AukkwGnXsD6LNuT5wzAgkvDra8kAudZgwIm9uOakbVvBDlRe3yGvjKNJ4zqcfWZFJxEkEgY33fgWy1fkoQn472Pn0qVrcwBue+IzJv26mPRYhOfuOZMue22/leFeuft9Zk2cy8kDjqHv+Ydut3ZdrFywhruO/w/rV2ziuEuP4uYhV/u68H84UrZ4+6PWeIqLErO3WMYnqpKKzwpB764IlfVJr+Xu9x213jHTa08ETD8YUqAMusbZrT6mTlpjpm14n8mbXgaCJF2R4KiI0jC9LUtLFxO8WwSD/XIi9dkQ34iJESoDcFen/+O3/Bl8uvJjSswy4lLHzUxh4ejzvBRsUGSWUpAsIje2bYEUZ4wdxuyCNQB8smwmr/U6j0vHfYwlJXWiaUw87ToemTqOhJOc9JNFvzOwW2+aZdfh6DbtmHvtzdvU75aw/z7NGX7vjssxPHXsHCZ8Pg3LsFi7bCMvDH6Hhz/eMefyT4H70JhC7UZp0lCkNywyw7esflYJ156KoNF0bKZ0Da6rZfA8GwIMp01X4iADxxHe/578zZBopkBD0LZefb656lIAej/9MhtKS502HOttqaYa18tCM2FdfqlHeAEniE/hpj69ufrlEb6bxCG/IgafDbyQK14bwW/L1mCW26QVg9TVS0vKUPCfMOGDcb9tMyk2DINjT3zK237znZ84rHtbxn49CxAcf3I3uh/UjpUr80jElSRj6NDvee55Jdl4fPCp29RvTXDVwzVfcGRb8OyAoaxdsgEpJd+/O4nDzuhJj2P326F97upI2eLqUWsC7UrNhVssE5RDuFBxGRU8v8E60onNQBlMNeWlSLW7VLM6roXrSIEhdeXxlUp+8cHSMygz85m8aajyJkvfeLt/68WacVCDC1QqNu8FAp0MPYfu9frRIr0HH656pdL5tchoR91oA45sfDRN0tpgyigEzk06hBgI5SnOjlT27tYULiF2cdG4DzAdN3RhMsHl339Iuu4/m0kJafo//1ktUernbpa2pLxkywEutx/7IP1i53JBq2spLynfkcP722BLUaNXCrsvTG/e1vXu+rbODQAGJ3+w85IWSEuofQECLFF6YukG0BmA6ToawMs/7B0XCEORTGwQFmgG6KYKpgPB4rx8jn/lDV77eSobS8pwA+2C9wAh4Y7DDufibvujx0GLo7IzmJCbkU6LenW5/chD+fK730km7DDBteClC05F13VuOqwXLUoySMt35hdtv/1QNLOEjL+wguYrr08MbZeWJhj71SzvnL76/DeKC8s8J46mCTIza7Zgx66O8pK4l55PCIiXbt4Wr5i/mtMaXsbxaefy3A3DdsYQ/xakbHHVqDWkuF7GQdUec22mL1/wjwUn01ynhPeSvnzBjzNW+0x0bHQsdCxPGiGwpcREx6pi+WZDary28AxvDKZT312BzpKwPrmBz1c9TvCGghTEaIBm5zJp03imFY53zsQ/kRhp/GufhwG4bMqVzCudh8q0CUKo9fdsAlkpHELfIn0PItp2JKkVfmS/563jpT6nkJuWTkYkwr979qFBxraT8L+KVavy+PHH+X+5nZ7Hd6NF+z1Iy4iRnpXGlQ+cudnyL9z4Kr+OnY1lWqxfsZErOm9dzuV/AlzvRE1eKey+SNfdh3EFaQdn3ATS1gKBd26wnea9xyXOEidjg6ZkDaZwgu3cJ3rHY5wQYKiXSPrkVhiKEAsT33475HnR2nweGztJ9ZFU5TQTL41axIAHPxnLs2N+hMDZaCbklOjsYabz7CeTWLB2E8KNc3PGfFWfAzm8Yxt+m7uCax79iPX5JegWCMc7rJVL/wYTmLJ8/JoTt/ma79k0d4tlcutkcFSfTkQiOs2a1eOmm//eOInJo6azfN6qv9zONU9cTHpWGmkZMVp1bsFBJ1RevCtUfr/BlOSVYBoWI18aw8QRk//yGHY1pGxx9fjnu+RqiDZ1L2VJwcvISuHGyqC5ywTbMqj59YPgoqI+zXNOZUHhG0BFJVpgW4LtRW24AXi+3s2VKgS1ay4ZtQPPKBq+dCK0Sp5MOF6VSKh+oV2EKYsAzdNLadLPAvFYt+FeectZGlUtj+pfBeGQdnd/hp7G093uqupy1hjXdziUF+dOcs5JBG526q9h2RzSrBUzLxj4l/rZHrjjrg+YMnUJoK7N6C8Gk56+bT+RWHqUZ8fexdplG8ltWIfMnPTNlp89MZxGKG9N/jb1uyvD/R6nULsxqPORPDprLAS4n59M15FPuLrgIByb8fLhp3HNuM+RliOLcBDU9wKOQRfeMc9b6JJiN1OEo9oQZlj6oMoCmqMhlg6JdsqUYhBMUKEBIg4bzFI2bCpVdQRoUZBJNay2jXK5qb/Szd435Cuc1Ug8aYWUEJEgkxLbeXYQBtx0wRF0btN0ay+1h1NO6s5rwydQVKxmsPZq3YhlU5ciM5wgasNi3vSlDL71BAbfesI297M9YJom/TMuwHayb+x3VBee+O7f29xe18M68v6qoRRuKGKPNo3RtpC5yEgYoe3Jo6dz2Bk9t7n/XREpW1w9ag0pjmjZ7NfoORbkP0WpuQQ3m7CrYrNxvaPBL4rjPUWQkPksLHyryowVIlDfW5DD0xX7HuaKz1yqX62KI1VB+ORduB9cFF3EKDTdqXo/o0QQbbM6eO8nb5zilXFn5gwn0M6wQRe+t3jful22KgCt1Exy9g/DWF6SR+fcprx9xGXc1OUobupylFfmzK/fZtr6Fd52w8yqVtH7e+ASYlDn/8QTo7jnnm3X0mmaRrM2NUvVdvINx/HM1UO97a6Hd9rmfndVKA19yhDXdpzdpjurS4r5ZOksChLlihQK6WmDpQRdaFiuhMDTSiit8dVjv3B2udrjsLQhoFkjHDhXIdDDeUh3uxC230qVdl66tfAMuhBK1mBYFlbS9rzJmnNDEFIRYmKq92euPslrrzg/IJGSSj6RudYCW2JHwMzSQUCk1OKiflsX5/TjN3N48tb3sS2bq+4+if7n9eLzCjENx3e6EztpqZShlk2nbq22qo8dhRdvfNUjxAAzf5jzl9vMqpNJVp2azUA2aFqPTQGnxGkD/96HhB2BlC2uHrXiqhSW/8GYJZ2YseF6Ss1FuITYRU6kA3VjB4U8teAGYQS1xK6XWXgv16ucHWkbJrgCz/gG40FAYkkNQ2qYUvOOKA2veu+uMofThOUM1rJVlHaDWAtObT6YuzqP4Oo2z1UYtz9eS8LZe17Fje3v9/b9XvSHd+6uLMMm4vpOsJylom005hRuWYcdxI0/f8Ci4o0Y0mZG/ioemvllpTIf9D2PJhlqXdKsSIwv+l+6VX1sK/5YuIZHho7h5xlLtlzYQVpGbMuFthP6X9mXm4deTZuuLTnpuuP4v7Hb7hnZdeF/v7b0SmH3xKXfv8e+Hz/Ba/OmUpBI4OYOdonw9R0OQTMjWGbA9kp82ZXlL3mv/vf/uX7gqIyAJdSiFmHj6ywIpCRnuibQkkoPLAy/Tb9PR9Yb9B67twBb7e+5V0tGDb6UGY/cRMNIhrorWHgkV6Bm7PZu1ICv7r+cNk39VcSkYat+nZX3IiV+WLVuQnqhRXqBRcRQgXJbg4evf5Py0gSJuMEL935CUUFZpTL3PnshEQHCsul5VAd6991y6sztgY+fHskLN75KSWFJlcfTMjc/q7aj8c7y/9H71ANpu19r/jvmHvbq1uZvHc+OQcoWV4da4SmevDas5wx6iBHZ7NfkWX5Y2b9SPZ84u5IHn9iqNvyAjxJzBZl6U0qstbgZHKRnpn3yrJZnrkC+nTZ0JCaQodXjyn0+YcamUWTThBFr7yNpa56+eFX5WiasH0WztE58sOoF0kQO5VYxtgTDSTXkZkzu1ejoUF+HNuzNuA2TPM2wKbXQeeGdKfRtvHWRzstLw1P+i4s2Viqj6zq/nHXjVrVbU8xdvo7pC1bSZ//2NA0sO/rd5Hnc8+woAEb+MIcrzujFlWf2rlS/37Fd+drJmRmN6gy66dgdMs7q0P/KvvS/cvulndvV4M+MpFAbceuPXzB+jf9Q6sq0hBM4d1XHnszcsBZTBlho0CPs7a7anyukABOObNOabxct9pcuDRBjTaglnaWEuloaRTLhNSUJeIOdvu489nCO6dCOkbP+ZMrcFfyyaJUKqHPq/DpjOT92WIw0bFpl5lDgkE/NBN3hsVYE1qzMp2nDuqHx7texOdNmL/dSE0WM8JxhcHYxuhVBdsmkScVUqxvXFlAnN+wp7d23M6PnPFLjdmsK27YZ+/ZENA36nH9YSK5weeebWfGn0gl/8b8xfF4wnIzsjFD9AU9ewqiXvyFRptKJHnFOZVu9I6HrOg98cttO7XNnI2WLq8duT4oX5b8a2nZn1lxzs3fdK9CqCSRTZNGljBWW2JC+LEJpgi2KrXX4QR4EVrLzsV+Da5i66TW/GSnQRQbldrkTsKfRt/mdAHRrcCJSSvT1OVhWHBDejWRZ2TwemTfAXw4V4RFid6yiii/9PnX25rYOgxizZizT8v508iornN38GH7cNIcNiXyObnwwl7Y7ucrrUh2u3Ls398/40rvBFCdNyswkmZEd73H9eMIsHnnvOwCeGjGBd+68gA4tlHThpffCkdfvjJpaJSm+7db+/GvQccTjJtnZf6+3YndFbQzcSEHh46XuNLiyqdJZtEMCGRGNs9rtx7y87/0K0tcCCxmwpR7Rdeycy2SdTBXfLlgczvYQmr1T1dN0nRZ16vJ72Xq/LwlpukYiYaNZUCc7xgUH709E1xhwZC/2adiYX/9cFeLitpT85/WxSi6Bc0M1QlmT0U0QVXDaZ+4+gyHvTeLnaYtZtmiDd2qxjAhXXXAob7zzE7ouePGJrUsdGYtFaNqyPmuWb0LaEpJJ5k76g7Ydtl9u4c3h8o43s2qByjr07sOf8Nqf/kqhLiEGkLZkxNOjuLCKhZJGlbxDSUk56elRIpHdnqb8LUjZ4qqx2z8qFJTPrGKvE4hGJnvVu4Z0rQlZkdbe0exoezSRHpA7uAF4bl1FfJVjQsd2guC0wHFL4kgkhCdTMKVOm5xjyNQbelOGNhC3k1hEsYlioTNyxcO8OP9Knp93GfMLp5G0tErk2kZFY7sBc1UrfyOYtsn4DZP4cs03WJaFlJJFJatZUlqIRQa2jNEgWo//dr2Di9qcxqD2l9I6Yx9sufWk8Ny2PTi31YFg65imxryCjbz8589b3c6WsK6ghMFvjuKZUZO8fS+P9vuREl750o8YblQvO1S/Tlb15xaJRFKEeAdBytSUXQpBOZq7LTinXXda59Tn2s490R3Zg44gOxJT5Dc4vedMc3k5f6QAU6jllmVQ3KZSqXlZJgxVX1jQQEvn9mMO9wYiAD0JZpmNnlCe3tKCJDcO+5Q+9w7hqhc/ZuPGIty1kILCOs2VWXgsuOI5S47r1p68vBKGvzWR32YuByAvr5QNc9dTNj+PrCKTbEPS84A2jPngJs457SAuPnpfumRksXHZpq2+ysPG3k56eSn2ug1Yq9fy4sDX2Lg6b6vb2RLGvj2ef5/+ONO/VffZvLX5HiEGWDFvNQUbi/wKFXhY2/2q1zFnZ2ekCPEOQsoWV4/d/hvXrv4ANq4ZCwQf8F3Pgdrz05rLKDWXesc61LuRKetvRgViqLKmQ3q937RU8rRgKIdEeQ5ckuyWVqL2CBLBh0vPAwS6qEO5XeJnisAmKaNIBOUyibTXAIKPVj6AITXP6+ynrQzcXNypP6SSaUjpBAdqXD1tIAmp5vE+XvE557e8gHeXjSZhBxb2EDH2ymnFkpI1XDNNPdVPz1/AtE3z6de4N/8339cGf3jIQNrVaVLt9a4Ty8ByIr4N2yIvUVnLVhEz16zh7Hffx5SS7s2a8tH551VbtrCknGMe9HMwfzH1D+48+UhyszLYVOT3tUc9fznTp+86nVOuG0pxaYK0mM4rD52/xTGlsGNgV7wrplBr0Dm3Cb8XrAPwUqq5kEBevIyzvnrPSYmp0SanAW2y6/Pt0gXqW2M7NtAWSJf9BrXCOFIMV9tgKSLsEmSQkATNEqyPl3HxGx+Tm5GmMjJI37YLUHmMJfz453IEsKloBVP/XFFhzNIr51UMnA+oQDs9Kfn6mzmM/dxdQOonTj6xG3OmLWX54g3estUxTXDovq3RdZ37rn2DqePmATDzl0Xc/dz5vDDoLQo3Kh1uelaMTxc9U+211jQNu7QUWa6C+YSmUVpYRsNm9Tf3EfGfc59i/Ic/IzTBPe/fzOFVzKi5GHLLG4x4erQ6o8+mcuKAY+l78RGVymXW8eUR/xo6gKeveRlpS7of05XeJ1efKjWFHYuULa4auz0pzk3vxL4Nn2Ju3iPoIosyay04qXQMmWTk4n0r1JBMW++mIfNJrUs5XQOoJG5RNFc57AbDqcy/fnOOXk6iAt/cdG0GxQQd9dLVHcvKy0QHYdmQsKNOVgzlpVCziRoCgSkFSanGYFmCJEmvrYRM8sum6STtcNBGianI5NtLv/P22RL+KMzj94LRgXuP4IKfXmRyvwdD9Qf+9ClfrfiT9EiEF3udQd1YOoZtoQnBZXsro7e2pJh7J47FtiUd6jXk2u4HkZ2uPLJnvvOeJxf8dfUanpn0IzcfekiV5z98wq+h7Q1Fpdw+bDR1MtLIzU6nsDTOXs0aMuh03zhnxGJ8M+yGKtvbHojH46Snp7zLW4L7PU2hdmJU/yu48oePmLFpNU0zcpidp6QLutB4Y/Z03pj9m19YwKLCTSzckEcweFk4+mBXhwyoFeJcrzE4cguc/MO+28JdEMNdihmgsCShsk4Eza3tdRcajxSgC3dJaomwIBIn7DaWfl293EaznaxBgSWbAUZ9OZNIwgrNAJqGRaGjSZ4+IZArPZ7g4YuHECwcL00y55cFdDm4vbevYEMhV3QaRHF+CR0Pbs9l/zmXV257B00XdOvThZYd9gTg6zd+YNwHk6hTP4dDTzvII75Tvv6V8R+qGTdpSx46+2m+tasnxSNf/jZ8TkO+YdSQb9i/TxdmTVApJq/+v4uIxXztyPFXHM3xV4TjXLYXTFM9GaW8y1tGyhZXj1rx7Wma04/0SBN+XnuRt88mDWct0BCUPSylKlIq0ZSHAj+gzQ6UVEHHmu/NlVKtCoPAksIhxL5GWZUh0J4IZCAKl5FSBcWVy6A+V2IDjWLNWR0vIG6Hk2zqOmCFz6NXwwOYWbiQpG0hgYjQuaClShO0b25bvls3A4Ckqb4a7nhcc2zJcB+3Tx7F6OV/gIAy0+DqHz9i2qmDWFy8iTbZ9cmJpVOYKKfX2y975/rd8sW8+NtUplxyDY2zswm3CD8uX87NVE2Ku7YIeKkD3qai8gSPXnE8x/XoUGW9HYEPnhzFa//+CAChCz5bNyRFjjcDicCQtcLkpFANhh11Fld++zFjVy4CICeWRpGbhSIICbKiYQAUMxa+4bRVgF0wR7EARZTdVfIAbKVL9oLuCKgxhE+S3cU7Kll/36uBBuhxPxgP6bfRfZ89+X3qcq89KSRogkhMxy73c+RHdI1DDmvH5J8WYpQbCCHIqZNBvxO7AZCVk0FxYZli4HEnGDCcWJ71K/PhYPU+Ho9zQatrSTpLNP/x83za7d+GV/94mrKiclp3aYEQgqG3vcVHT3zhtfHDez/SbK93GT7/BSaPnF7VBa8WdRvksKGssrRj9sQ/+Tr5/la19VdxdtOryF9XAPz1vMa1ASlbXD1qzaPClLXXhrYliUplKskrHHi2T+KvquS5BzQvo4Srv/FJrI5BBAvdn75z2peooOOE1Cm3I0peIRWR1rGREhKWRpGVRlzGiMsoppeoPtx/i8xOIUIsEJzc9FTu6/gAx+/hZzPoVqcLfZr05tF9b+GilqdQlshiUzzKkPnfYJompzTvTc/6HUOe4Yq4sb3f3qlfv8rHS8OabcO2yI6mceO3o+ny5vO0GvZ/3PTdaDeIPNTkzWOVLKN+BSI56JDqvRNHdd2Lo7u2Uxs2RJL+sca52VVX2kFwCTGAtCR3nfREpTKmaVJSUHXqodoIS4oavVLYPWGapkeIQVCc9GeyKhd2vcHB4y4xdFy3VS3wYQs0IxxcpxsCzVT5g4NL2HtlDCCJ0hO7WSvcP6ZElEui5agUbq42OTAyzYb0iM76hXmhIL+9WjXiukuOYNT7N5JbV8kIhBA8+p8zuPu+07jl9v707NYSfV0hpfPX8t4LSur3wic3kLmF2IY+Z6hZuHg8zkmZF3mE2MWfk+dTVlTGgO63clzkHE7IOJ9RQ76p1M7qhUrSct6dp4X2R2KbJ00vTXuMzJyMSvuj6du+HPW24MfPp3iEGKrPa1xSUu55k1NI2eLqUGseFSx8YiIdzZq3HSpZ+UugI7CCnttwQ54TwXAup+5IKqyACtn93w3YEwgMYv7SpghMVPI204ISmUaY/Koxa+jYHk0XtM3sxqoKT+ua1Dl5T7XoxIVZrbiw1dmh4+2yW3LLr69iOEk3C81yjvjhTtpmNeOt3mp54efmfsXbS1XWBk1AtzqtGdy5P/vU3dNrZ7ajDwxelFbZuQyZ+QtLi30j9cOKJSFPjvt30bo8rvjwU9499xweHT+eJXn53HHEYfRuVX3wBcAzl6msGGOmzeWe18dgSZu+B7Rn/72ab7bejkaiPBnafvWud3n/v58CoOmCz4vfrNWe5NQqSik8M+NH5503nYaXgzhoiO1AGfdYqJxTL1jHmTnSEsprKy18yYXbmmtOHeIrJCpbhOW8d/Z5DtmkJBIP643dRUojaJiWUmbGohqnHNyR78bNDYxH0rZlfc479UAAPv2o8qqdR/ftwhPXveltf/Xuz3z12jgGPXk+I6b+G8uyOKfT7ZQWKW1wvcY5dD+yE4Ofu8Sr8+rt71ZqF+Dc209lYK+7VQYK1EptdtXudwb2vptOvffmmYkP8X9XvETdhjk8Oe6BKsu6yG1Ul88L1dgH97mfmeN+J5oW4YFPd246s7LCLcetnN7gUorzSwHo1qfLbpoHvuZI2eLqUWtIcWXYeCvAAWGz5+VT98ToOpBA8820E1DnBtyZRHAtrhVoNRgdZ0q3nH/YDaDTUO3ZUlBGDJ+0BwLqEFzSehCj13yIbWssKF3HtOQCAEdRLCmx0rCkxhk/XcdhDQ7k5n0uq/Lsi4ywIRHAwpJ1fLd2FkfvsS8DOxzPmS0PZm7RKo5o1Knale1sWyCkRGrQLqc+Y0+8lhu/H+ldYmGqoJjT9+7EJwv+UPstdSw/v5yJ+UuZvWYdkwdegya27qn0uB4ddqpcoiL6XXI4Xw+f4G3f/374pucSYgDbktzT/7FaP61n18Jo5hR8tKpTr8IeQUg/5ZDh4Ep0mIQIcFTTMCwn1FhDZYRw10EqD7gQJH6uYheu3Q0s1+x5dgO6YA3AlkQSFe8MTtsCTjuyKz9NXwwJm40rC/niixm4/hZhSyKlFuNGzmH8yDmM/uYW0tLSKl2PeDweuke4eObW9zj2nJ7ous7H857g1/F/Uqd+Nnt1bVGpjZYdKzsD7vvoFg47oycPnxcOxotENLJyMinaVOyfi67x5+T5LJ65lLSMNN6Y+1yl9raEJ76/f6vrbC/0vfhInhkw1POUN90rHAj+9Rs/eIQYYMb3f32FvN0BKVtcNWrNVemQezvgZ2oIn7rr0fUJsYkWWKFO5QCWzj4bDQMdCw1L6IHgurBhE461tyUYaNjeM4ggIB4GwLA1EpZO0g7muAgQYqnW05u88RcWlmxgcdk6NAGGDYYtMG2NciuKJf1Av4mbpnr1FxSv4sRx99L3+9t5e8l3RLUMT+ahxqiux7pyfwGOZpn16bNH12oJ8ektuyKTGlZSRyZ0YqYy+v/ufZQixEmBsAXCEizalE+vnBZEinQiJTqxMs2TBBcnEpQmk1X2sStj0ItX8Nqsx/jXkCsZXfAqjZo33Gx5I/HPO8ftCXf2pCavFHZPnLX3vuyZ5Sys43hpha3sRLYWQ0gtTIgNHGLrh8wZSYlmKbsiDIFmCTTT+SvccoE2gkFwbgCeXZXFdoobIAyJiFe2xJ7FNizGfj2HDcsK2LC2CKlJpC0RtkTYamnmYPtXXjLMa//lh7/gxE53ctERj7B6aZ7SDbvG2PHqut5dF92P6FglIQY4acCxCD18JvX2UAuFHH3BYaH9iTKDG567DD2qeycmNFU3UZ5k4W+Lq+xjV8fosne5/9NbeXrig7w5/4XQsURp/G8a1a6LlC2uHrXijH/f+F/mFjzm5AUWyICHuKrJJDNEcl0j6xsp25nKs6XAkJrXngspIWHrSgtMhIR0yWq4jHTaMpxlny10TBnBDmWpdwL2EJSbMSbnT/NyYgqUx0JJLzRnERG/fRfJZJLLfnmGAjNOuW3z8qKvKEomKDcjJC2NpKVjS4GOxjktD610Pd6YO5V+o1/hvqlf8e3y+eQ7aX6+XbIEaSldn7QEfxSoBPQN07M5rXVn78YkEMzduIGpK1fj7MAGMqIRMqNRejTfk5wqvCj/BOzZdg+Ou/CwKiOe+15yZGj7gc9u3Umj2jUhqZmGrTbq2GoDyswkB7z1AqsKSxCmACNMS0sNww+elZCmafiLOFftsfUMuA0iSUjPC6odLRl4uavGVVBeuAF2mqG8vMKCwEJsfkyvBGHYREqgtCwZCO0I0HC74iDAsNRAn7rzQz4b/iOWabNxTSHXn/QMJA0oK4dEEhIJkJIjTz2gUhvJZJK7T3yUAd1vZexb473cwKBiGoL436DhANw+/Eb0SPj+9PzA17AMyzsxy7RIy0wjLTNG/6v+uStqHnLKQXQ5pGOl/adcfzyxgM65dee/V2a3KyBli6vHbi+fMO0ylhW/DQTz8rmqXjz5g4LO6e2m89GisEFSeSTDC2goTU4FM+3kB1bEW0dIlTHCJOKohi0sNAyxEFgAACAASURBVDTAloK4jCDRsW1Fbu1AgJ4lI4DECCzvbKApvRvB2TZllaUtKTGjRDSlaQbokrM3AP+dOyI0TtfAq+TcutqSkuJkhK6fP8wdnftSaJpEhYYmBf+dOQ4kzCvYwJtzfwOp8eyhJ5MfLyfoQwnekPq0bM0Xs/9E2CB1aNs4lwXF4WWgH+p3DLrQOLJda07973CWrM+jfnYmHw2+gIZ1dm7Q3I7Aba9fz2UPncO8qYvoedIBqVRBpJYWrc24/6fv2RQvJ5jNRkH42mKH5F7b7QB0EeHF6VPCjUhH9hAw5cLyyXDIwrteYfeAk4pNOt1pbjuWWqxDAxUcognVhy2d9G1qwJojufDn8iRBiu7O/QnTRhiWyt/mGOoXXlIa4G9HVMjw4GaUMEz1EgJp24wd8iU/vzeOR8fcwfdv/cihpx/Mg2c+6ckeHrtEeUPTMtO4+IHKK8J1PHgv731OgxwK1hV629EKAXSZ2ekMeOpS2u7XmuJNxfTPugAjYXDMxYdz22s7LpXlzsTosneZ/u1M6jWpS9t9W//dw9klkLLFVWO3v0tLx8r6hFZUMGXgmzibUUtODC+S4RjweIX8wa4O2ZaOF8Px2Nr46dokvtZYkdCoI7Vw2rWh3FnUQ+nYbCypY8goILBs5QF262tAUgqiDjM2pFo5z7ahxEzHRpC0lBTDkho/b1xDuVFORpXLLAuV8kg4umYEtlSShgdnjvUybAgJ0ha+4kNTASx3Tf6q0lU8qbX/lH7n6G/VzUoIsCRlJQb10tPJj6uprHYN6nFKZ1X+gQ+/ZfF6tdrSppIybhj2Oe//a+uWNt0SLMtm6fy11K2fRcMmdbdr25tDo+YNtyirqC2Qklq5QlIKCuVG5RSYvjF2XbeKJP7v119pXaeuf9y13xaIQJpJ4dZx34vAfme5ZYQjiZDOYdshtzLQrq2IsT8oJ+2aVO4TzZCe5MK9lwgTiDh3AicPsWZYRMqUF1YYNiRMhIQXHxnJv5+uwqbZKmxaBKb4pGGChNL8EgYedA8Anz3/VZXXNFGWYOpXMyrtv+H5KwEoKSgJEWKASx88h6euetnbvv75Kzj24iMB6J95vqfN/faN8fS98Aj279O1yr63FUWbilm7dD2tOjUnLWPnzRAe0He/ndbXro6ULa4eu/1ViWrZNEjvGfCsSn+GTlZIYC2h1FqDjcoSYdsqZVrC8egG5RSul9hwiKRLng3bSdFmU2HqQYQMKijCLANt2mgkAjKLYHUhXA+FIGHrJOwIpqM/tp2Xy1wjmro7GNLknjlvcGunM7Cd1aCkhKSpCHfCjCjibQkSho6Umpd2zr27mKaGtDWkpWFbfhu6pnFa206B66zzxOH9AXh6/I8kTMuXT0hBQTzO1Juu5aXTTuSNs09nzFWXenXXVUhZlley5WjirYFpWNx60VAGXzSUK/o9yYSvZ23X9lOoGaSjza/JqyYQQvQTQswTQiwUQtxRxfF/CSH+EELMEkJ8J4Rotd1PKoUa466DjyBaUZPg/g0SVAABywoKfY2bszqdZoY9s159u0I70g2W849VmggO9BlxV8RzS9kBEo2vQQ52LqSvP1aTbRIt6VliBV0FZ//8wzzKy5Nc8q9jA/phG8rjEE8gEwmwLKRpYjvytKoVz5VxyGkHhdKgHX5WL+/9hW2uq1Q+Eo3w0bph3Dz0at5e+pJHiAGMZDhl2ZrF69iemDd1IRe2uY7BfR7g8o43hwL+Uth5SNni6rHbk2KAg5sO47A9P+OgJi+TE90b0LxgOne5ZN8+KgWblBqG56UNZ4Jw4yFMWx0rt6OU2lHK7DQMopTLKHFiJIli2Zry3Nqudlh5d00pvOWQXUgpMNGdXMiguSnfHMOdG8nl2W5P0jjWBIkgK5LNwL2uwjRVrkjLFiQtzSPjUsKGeCH5yVLKk1FKEuqVMGMkTZVv2bQimFYEGcix7I8HJw+o85JCpTmS8NpRZ/LMUSfywxlX8Frf05l38SBiTkDeyD/nhm94wPW9VJb5Y/duz6Ft/p+9M4+3ofzj+PuZOefcxbWTfc0WpZT20EZpU35aiBQlQtrQprSpaFMqpRJFRUXaEZU2WbJElD2763L3c84sz++PZ2bOOfec271ElPPpdbpnZp7nmWfmXt/5zvf5fD/f2H8P/S48Pcb897+weJ3i/cHKXzay4fftBAvChEMmbzz9ZcJ2pmmyauGapJblQcSBSu4QQujAi0BHoDnQVQjRvEizX4DWUsqWwPvAyAN8OUnsA2pklGNFz0FMubQrd5x4JpVS05QSjYn6GR0tdutcOIZZOEU6kFGOq/NTk3hyapiu86zGFCZeYh2Ws8+hVXiOdNH8V5eigXJ0cdR1vGeEEDw17H/cMeB8Aj4NTQhat6rHQ3dfhmZKpG2DaYFpISxvICzT4o+F6yE3T33y8rFNE0wTbBtpGEjDINbb/2v4Aj4u79+Rj3Pf4rFP7ua1Fc8y7L07AGXP8rMLYzsIOKfbWVSoWp6Lb2xPtbpVYw637XKa9z01I5Xzu7ctcQ77grcfeZ/CvCCFuYXs3ZXN1+/9kLBd5vY9bFq95YCeO4lYJG1xYvzn6RMuygYaUTbQiGplzmB55lP8kf02USwwlXAQxRYDZXy9nAkRcTQBJLpyYB2HUXh8i0hvyxZepTrQFXdZCkKWTgi/GkVKj9ARtp3yzKhKeNJx2iVQUa/MPS2GM2TJM+wK5XNc+eN5pKXie01rewpnf3VHEY6QcuX/yM3CL3QvkmzbYFgaUqrIgqZJNAGnVq7HL7u3Ygs4vnI9fti5Me4eSinA0MHWeHjO13Q9tiVdjzuehhUqx7Q7sVYt/tyb42VQX9SsMX1OLb7G/XF1q/PZ/b34evk6Tm5Umya1qhbbdn+QUS4N25mLEFCuQnpcm8Vzf+Wejo972w9OvYMzLo1Pdkli/yEdutEBwinAGinlOgAhxLtAJ2Cldz4p50a1/wnofqBOnsT+IeDzcUqN2pxSozZ9TjiZY1553lm7EzEv0m56czR1QkZHbl0eshsJxnF2o7lxGhEn2IqM6wygkumKJOdJx6JrUVxkYUgnOKAGv6V7G/J25/PqC3MIIHnwnsto01ZJQ1Z5pQx3XvdavD9rS5644x18VqSqnW1ZKsHOO7lE0zSantKI1Qv+oHLNyuRl5VGQU8SxjYIZNhnS4WEGv3ELp1wUa698Ph/+FB9GKPKS/96OcX+Z23D/u3fQ4frFbF+/iw492xFITUS923+Ur1oOn1/HNCw0TaNspfjckYGn38Oq+WsASC2TwsdOTlASBw5JW1w8jhinOBq7CqM5WMKzrTFOMirnwsSHkNIzphKiHN2/hoXmOctKi1hFiUPS7zjZAgsbJBRYPsJ2ChIIaBamLRFC8+ah6eXp/fODGFIZuCXZq7lv2Qs81nIggFNC2pmjlCp3Q+qARoY/lfK+VPYaQQwzmrKhVvAmtLmOU6o2SHgNnT97i0W7HNUIE7A1tEKN5YU7+XXOVyzdtoMnOnSI6TPy4g4YlsXCzVs4t1FDHrnw/BLvVa1K5bm2XasS2+0PGjarQbd+5zDltW+pVLUsQ0ZeFdfmkWti9Tyf6DmGGVnjD8p8jmTsg8RPFSHEwqjtV6WUr0Zt1wL+jNrejFf0NiF6A4mJmUkcEqT6/CoSCzH2NaEkkIzwe6WUjlPsRJRjzXZkoCKUCRFzEiIOs7dbgiHRQqC7jriuCnu4nVKFIJQd4vHnvvLGffDBabz73i0cdVR5CvYWxipgSAmmCkms+30HT711A/M/W6Ic4sJYqbBK1Ssw5ruHqFyjqJYz7Nqymx4NbsEy42/OL7OX061uP6ZljSejSFXPFxc8yaNXP0M4ZHDHq32pVKVCXP+iOOXCE0tss7/oM7IHm3/fyvrlm2jb5XTaXXV6XBvXIQYI5of46MXP6dS/40Gb05GKpC1OjMPKKRZC1AEmAtVRpvFVKeXoA32e7PDvRFMhgCgNYUnFQEuCtomwdmNZOUhhI1GOpktvAEWsUN8lpq1hSh1NpU04iXESUxKTtGc4iXWeIZYaYUsQtFO9OYVtEFYK2d55oHqgOitkpncNUsIPu9bR9isl8xVJmlM9TEuj0PSThkbz6cMBiZR6jEOMM3pxDjHAxPOvJiMQoOfnU/l6ywaE4c5J/fxw1Yo4p1jTNEZffvFf/g7+aVx109lcddPZh3oaRzQk+yQYnymlbP0XxxO9lSZcbxZCdAdaA+1Ke/IjGf+UHd5TWEi0nrDrEGtedFjSunotsvIL2JVbQH5IJYAJJ6osonnERGy55kSFXequ56TGOKvRiXUKQqrkOne9UKKixFrQdhxjsAKQu7fAmYczlGXT/aJn1bZlQVQQBYC8AtA1jG0hep80XO1LoFlerlJGQocYVIR1Rs5bCF1wWdkemGErrs2EB6fQf3SvmH0Njq3L6yuei2t7qFCuclmem/fooZ7GEY+kLS4eh5VTjIpF3imlXCyEKAssEkLMklKuLKljSTCMAlbtfZFKaa0p46tFnrnBO+boU6j/S8HW4ApAaQdrKEfTtgVhdIeioMISSilCcXi9SnUoiTNbRqriCe+7Rljqrr33zlpgK7UJz1FHI89LdhNIJCtyNuATOqZUxtB0pNpcRI9p2lBoqmWvXFM4ahqOhnGRiErXBokpAmv37KbjuxMJ2zapuo+vrr2BWmXLcc6bb7AxO1LCOd3/z9a5P1gY9u5tMfSJ+94eeAhn819FtIzh38ZmILqaQW1ga9wZhTgfuA9oJ6UMHaiT/8dx0OwwwM9bNvPJmlXcfEKU7SkS1ZUop3fRn1sjiXQoO4aNV7rZtXnCdrjDVhTFwnWI7SJmTzrKE+4+13iasUk2Hgsjqky0DNvUrFkx+tToUfQEdF05vK42cH6hGscwycv76+I9D029PeH+V4e8xdSnZgBwcscT+Dz4LgDttVgptuanN/nL8f8taHZaY1b9pCq1ppZJSUaJDwqStrg4HFZOsZRyG7DN+Z4rhPgNFZr/W8a4wMhk1p9qCX9tziQg4ERMpZLG9JLMBCGpe7QFHzaG9KFJO8ohFo5qhfAS9SLUhQjjLUAqaCnkW3lOzohGmqhMjsx35NskloR8K4XouIJludHkaAj2mrm8ccoIrv3xQQxbYtsCivxRBw0/lg12FDdaJvjDdyXnzj2qCcNbxUZ088JhRv00j3l/biRsqydR0DIZMudLJnW6ks+7X0ersS8Ssix8QvB59+tUm6DJG98u4Lg61WlzTPGR58MVJ55zLJ/mTWD9r3/S4Ng6SU3hg4B9jE6UhAVAYyFEA2ALcA3QLbqBEKIV8ApwoZRy54E68X8dB8sOA/T9/CO+WKeWxyf+upSyPj95RaTaJI4z61IjUD+FQ5dwHV+JszJmxTSLoWL4fRplAgFyc4IeJ1kAetDRVXcrixoRBQoPho1mRMZVPyWbd+zl2u6nM3n8d2qfFWVlnZOIkBlLjyhawt7vV4U6HLz750tULMKv/WXOMn76eBEfjv7M27fg8yVs/G0z9Y6pzY1PXstrQycB0Py0xpxzjSq8tPLH1cz/dBFX3HYRFUpBlzjc8MIPI9ibuZf8vYXUalTjUE/nP4mkLS4eh+2TXwhRH2gFzC+yvw/QB6Bu3bqlGmvB9kFR/UHKsOPICjRSSdEDnFfrTf7I/oJleybEGFhVckOPcTRtKQg6jrXwwhiu/rCkgq8Gjcp3YPbOD4BUyurlOSqlPqdVOY/X1o1Gd9I5Ck1/JDlOqoTlIEUSG5yCIJVSKtL35zHkmb4YhQjX1hqWFt0Fw1BV6qSMPCI0TVFA0jQfSzvfG3efVu7awUVTEic1WI6DnOrz8duAQTHHsvLyaPvQOLVhQ43yGcx64KaE47j3KBw2SUnZtyjz55N/4LVHpxNIDfDkewOo27j6PvX/K9x47O1sXLkZAKELZhpTDtjYSURwoKITUkpTCDEA+BL1j+8NKeUKIcTDwEIp5QxgFJABTHW4/ZuklJcdkAkcISjODjvH9tkWuw4xABJyDcP7i0jz+Tirbj1euagTxzw3GiOaXOx6wTJ2l7DwlCLcgdyosACevfZinpgylzxT1dKoXak8l7VuzvuzlpCZV6Ba26A7DrHUlJOrB6UXIUZz6GnOmJ0vOYE+V49VFt/1tO0onpxpR7gchol01CVwnX9dV9tCcMfYXlzQPX4lud9Jg1nzy4aE99B2FC2uHnw5Vw++PObY0ze9xBevq5ymySOm0fe5nvzv1ksSjgNgGiZCCHRf6aS3ACzL4q5zH+KPxes4rk0zHv/s/lL3LQ2iI+Btu5zKsCl3HdDxk1BI2uLEOCydYiFEBvABcJuUMif6mEPwfhWgdevWCXkrReHXK4Lh9o/st2ywRToZvqNJ02ohZFlA2SsAMyr1WWArB1YKQvg9bq5EiWBLGyyhJEz+DO1hw873ca10jplNZng5y3NWOJQLCHmUCYlhCQzpx/YsfoSELJ15Ns1ozPTs5c79Uddh2ZCupfFwy2t4YuXnbCnYjdAgHPQhZUQRw9UeVtelcUOTWMmzcUsW8ObyX9iZl098xgr4NI3Hz4nwhldt20nXse8StiwubtmMbEf2x12+3JGZR6tBz/LL6PjlwK3b9zLg3nfIysqnZYvaPDW8CwF/yX+Gm9ft5Pmh7wFQkBuiX/sn+HRDLFfusvI9KMwNgoCXFo2k8Qmlj1i7DjGAtCTP3jyW21/pW+r+SZQMKQWGfeBMjpTyM+CzIvseiPpecoZnEsXir+ww7J8tLvZcEiqlpNG6ei2EEBGJNXdUG2Jsk5tIF6Uf7L3/u3QHC24d97HXxrZh085sXv74R7SwUudRcm3SS+DTg6pIh2YVGVeVIQUL/lwXye3wBOTDFse2rsfVPc9kxIC3CRWqB440naeIEOD3I8NhJcHmPIjOu+ZMb6iCvEIevHwU29ZuZ8fGXQnvU4szmtLg2MgLyKheLzJr4jf4Aj6e+eZhvnhjbkz7sbdN4JdZy3n043vixpo+5jPG3jkRIQS3je3DBdefk/CcRTG0wyP8Ou83ABZ+sZRHrn7Gk4ED+GrSPJ7o8TwAR9WrwqT1L5dqXICu9WJt7rfvx72LJXEAkLTFxeOw0ykWQvhRhniSlPLDAzHmGTXHQBT/1kA5lAY+wjKXncElTFl/PitzphKSGmF8hPFhSR3LFgRtP2Hpx5Ca0heOXqRzjHY+foLSjyF9FHUqnSvzvsUuWwin1DKokIQzrFRfDVvDRuf6hp3QHOqGC4lGnmVwauWmPN/6OpqVqw1Sj3GIY85vazx24sXcduzZ3t7P1/7OYz9+w5a8HIywhTBFjIanlg/nVK1PgwqKRzdh3kI6vzCJkGEhJXyydBXLN27zeH7unbElzPxlddxdeHnCN2TtyceWklV/bOerb1cluFfxmD9recy2bcU+g/u1HqIcYnVj6N96aKnGLQ4bVmz6W/2TiIdaUxGl+iRxaHEw7DDAQ20cx6tI0hvA1rxcnvj+W5764TvClh1zXNh4ZZo9Z7moEINUEV3N1SYu6qZH/Vm5PrZymJ3kYSnR7MhD0QtRONxkYUGjBlU5uqmzQuVm8jltN/6+g1PaHkPvwReTUS5VGUFXXUOoLGjXLjdt3ZD3NrwQQ9O69fT7WDJnebEOMcB1D0WUc7of3Z+Zb36NtCVG0GDgafckTG+a/+niuH2FeYW8ctdbWIaFGTZ5ru+rWGZ88l4i/LFoXcy26yC7cB1igJ0bM3lh4OulGhcgf09+qdsmsf9I2uLicVg5xUJZjNeB36SUzxzIsTs1XESnhktoWL4vlvQjvYQ5BYsghXYmkdxjRT0IEcBCx0I5pyY+r7iGF8mVGdjS51EVbASGLTBtFZ11aQyWdGlykdLT0U6uZ4ydfSFTI99I4SitHpd+M4ICA0Kmj6Dhw7SEV3BD13XqZ1Rl4pl9qZdW05tfVOVQAAxDcGXDWLmdrzetd28AwvkPnIdQGDQ05q7bwNacHKYtXM6Tn8+LdHYeTjn54YQyStUqxGtQ2rb0ZJgAbJnAiidAm0ti5dr8gdjlvu3rYmlK0i7duB6K/Nt/cvYDidsl8TcgsKRWqk8Shw4H0w73bHkiG/rfyZq+g6ieViaG/+ti3OIFkbkQYSUIOyoyLCL7XR/ZLyI0CDeBzqNXOB/NSaoTKh8aKfAKdEQjwjpz9heapFmS7HW7ueGS5xBBAxGyEGELEVLZJWllVMniS3ucwaOv9cJdAFMSmRJpmt5POxSiQpVyMefc+se2Eu/fEz1eAKBThR7sWF+Emrmvsfq4Sk2lQ+sLTojZPuPy4jXoAX797re/PB6NB6cNjtlOK5dW6r5J7AuStrg4HG5XfCbQAzhXCLHE+Vx0oAbPDm5g5V711ioAN50tgU1U+6MYwzFek3RW0qRG2C5DgR3J0LBtnCIcGrYUmFLDdP6wVAlonQq+ytRMrYYtIWxr3tuYqpTnFPewVGlpiWBtcBu2ZSMdfWTlYOtICedXa+mdWxcak9r25smTL1WKFzbYFlimhhnWSPTrvqLJMd41uRAIhBT4TC3m2OhZPxa9QQSywRcC3Yj1K6tXyOD4BrXiztf3uraUL5eOT9doWK8K57dpFn/jE+CoWpV49K2+VK9biaOPrcXE+Q/HHO96Tyy3rk6zmqUa18UsaypnXXEyR59Qj6lZ40hNTd2n/kmUDJXcIUr1SeKQ4qDaYYBLprzN9oJ8EMSUs0eCYcS/YbsaxbE7I32EDcccdRTRKhYiSodYeA6y4hALE/x+QeXKZaheMQNMiRaSuP+hgbBsNEOVbtY0gRm22FsYiikbLWypxpQw6rWIHFrTVvV54cuhXNL7bKRlqUp1loUMBsE0ycmKLW0P0PTURiXeNzeaW5ATLKFlBLe+eGPcvrSMNG54rCs+v44v4KP/871KzSse9t4ddLj+bKrWqUyn/hcy6KXY/JG0srG2s//zvUs915POa8m4lc9Q95haXNKvAzP2Tix13yRKj6QtLh5C7sMb4uGG1q1by4ULF5bc0MHnG7uSbawhOghgoCl+DQKJ7pRIVo6nLaGQgIoAR/Fzww5FQkoIWjoGOm4paFuKmOIeytHVKLQ0wlIl0aVqZbio+kVM3PQRrqkXSGqkVmdd3m5vvpaEsO1HSgiZOqatx/CEQ6ZGyFBjnle9CS+dcY3X1zRNGr8XW0mxfplKzL08nic7c/0fPDv/e1btUOcWUqhs7EKB1KFq+XTYYZJTqCSFHJ8fbEhxStdLQOrQrd3xDO1ybtw5xj0/i/cn/YSmwa13X8xZ5zUno0xKAprH/uOz12Yx+bFptDy7OUPGD4g7np9TwOQRH1K2QhmuGtIJTTvc3gn/HRBCLCpBtzIharSoKHu+c16p2j55/Af7dY4kDg321RbXH/N0rIvrRB8E6ieW8OgPQqLk0iwRY7u9SnVOG2GA5r6cSxDhqDCAw0fTLNALXRqG5IJTmqJbMOub32LmU7d8Btu2ZUd2hGw0KRFSoueGQUplu5zkDlEYhLCJ0ARPfziIY06K5DMM7vAoS+euIDrycN87g2jXJbZwhW3bvHjrG3wxfi7hwsTybZf278DHL84s4e4qzLKnxu0Lh8P0bDSQzC1ZVDiqPK8uf5q09FRS01NKNWZpce9Fj/Hn6q3cNrYPJ7U/Pu74L3OW8/30BZx5+cm0Ove4A3ruIwlJW3zgcUQ4xRtzPmXRrvsxvOIVCkpaTSMoVcllN2xhA/XSz2dF7jxPC1g4y2yW1LCIKEAU2v4oJ1iqJGOiqBRSVbALWiqxThX50BBo2FJ6/GQpocDwE7YFPk060WDNO3dhWMOK4itbUpAfDHjbAO+f3ZuvNq3juWXfA+AXGqajUN+yUnU+6hgr7F4Uv2zdwr1zZlPJl8bilVs8E149rQy7d0e4XhKwA+DbG2FqS6BOtXJ8/GB8VGDrn1lc/78xMftm/vzP0hPCYYP/Vb6BYL6SQap7TG1eX/HsPzqH/wr21xBXb1FJXje5dIZ41AnvH1GG+N+O0triC957k9W7Mx0BdyLcB6mcYOGWU7aVXSvrD1AWHztzCyMULTcabEU5wLYqvOEdcx1pO4pbHJb4TIdzLKUq8ey2tSW6m6dg2wTybJX4LARYUtEupJJx0/NDEC3DFgxBQcjb1nTBpxue4+o6/di7S+Un+gI+jMIwaIL7Jw2kbZf4Sm7RGHPb6yyds4I9u7LJ3hHJcdR9WnxVu0g+uIc7xt1Mx97xuU23tx3Gr99F8jgaHFeHV5ceUIZMifhq8jye6B7hHQ+dOIDzEyhwJFEykrb4wOOICJUt2hUtGSM9Q2gDYY8zIzyOWbW0U6idcRqSNIdC4WgTO1QIw9YwpE5IakWWF1REuVlGS9L1DExbUGAHPPoEEIlEe6oWYFiCfNOPhUrEsKSOJTXvGVDNX4MP2t7NUydeSzlfWZV8l4DrsyBzk+cQAxjSpsfRrVl/7b0lOsQArWrW4vPuPamfUsGbmwB258YmPwhg5YjbqRHFGS6fnpLQIQb4Y1XJXLl9QThsMOC0e7gorRsDTruHcNgosc+yb1Z6DjHApt82/0XrJA4WbLRSfZL472HckoWs3uMoN4ioj5PeIaJ9PYft9eC5Z3Nd61bKWnq8CJBO1TpX8QZ3O2oIXYfTmtRBF6iVL6cNEOtEenOQiJCNHpRYGmgINOlU2EPx0R4feTVPjL2BXoPOR1g2GFasTjEqCfidJ6d7DjGAGTaZabzDzNDkEh1igAHP9WbcsmfI31MQs7+oQ1ypRgVeXhS7Itjtvs4JHWKArWu2x2zv2rQ7YbvSYvFXy7ii8vVcWrY70174rOQOwJRRM2K3n5pRTMskDiaStjgxjrgr9hLJBOgiI+qXrhxaacOGgl+YvWMkNmFcy62cUIEp3aQ7xQ92tf5cXrIpNVblLefeY0aRqldCYDuJHLYjaemGRhRMG0K2z5uZ5oQ1bBvywynkhFL5PXcPwxZN8EQFBgAAIABJREFUpV21Y/mq/T180HYgk8/qi1/EcsC6NTw5LndiS0GcklIMtu7N5vKxb3PRmDf5/o8NSClp1zRWyqxZnaqx2zWrAPDliJt4tOcFPHDt+Xzz1C3FnuP0ds1iaBJp6YFi25YGT3Z/ntU/r8EIGaz+eQ1P93qpxD51m8ZyjHV/6XU5kzgwUC+WolSfJP57mLd5fWQjysFFRD+IZOSgDYM/m8nIeT9E2mpRfaKq2qmCSI5ljQR8+XNPNq/deiUpQkRZ3diwqltWWphKfQJNgC4iSXhhC63QRA/Z3DfwbSpUSufqXu34aOGDjJzQm7tGxlaWq9PoKLav38W+rsJOfXoGPRsP4L5LRpC3VwUiajWK1WJve+VpMdtD3xpIoxMaMHXHa/R+vBtjFjzODY90LfYc/7s9VrP4kn4dimlZOtzbcQR5e/IJ5od4adB4dm4qXjnDRd0i+R51m9X+W3NIYt+RtMXF47DUKT7Q0EjDppAokR0EGp3qf8DUDdcRsiPcMTsqhOETNoZXbhkMqUUdd8eWWFJgSOHwitWxPUYmp1c+jw+3forHUQYsdLXaZUO+maICHFIgXNqyVIY430zx9ksJi3P+ZFdBNruCBVw2+3Vvts3KV6VsSgrPn3YVqT4fWIrbC2qsEae2ByBsWQR0deCPnZnomqBhlcqcP/oNT5e599vTuKDJ0TzX7VLuvrAtk+YvoX6FirQsV4Vzq9fHTIWW9WrQrvnR3vVffGrzEu9/IKDz3ue389zjn5JeJsCdw/6eZvefq7bEbG9aWXLU96i6Ven37PW8cd87+FN8PDD1zr81hyT2HRKBaSdfRo5UPHDGOZw/5c24/afUqM3YCzvRemysnq1XytkxuS6P2PWbvZJJrt3UiUhDOlHjvfmFtGpSmzJ+P7nBUGQ8CdLJiwj4HGqDs1Lo8ZYFCFsl2wkiB27u+jIzFwzn/uvHsXz+WrXTr9GoaU2an9yAfg934f3Rn6gxHMc4JU0VKrIsC8uyCAQCmKbJsm9X0uSUxsx561teHfwWAFvX7uCKStfzxJf3M+bnxxneeRRb1+7g9Etbg5T0fuJaCnMKuKRvB6rWVgGKClXLc83QK0r8HVw1uBNValXiyzfnck63NlxYSm3i4lBUxm3T6q0cVbdqMa0VBk8YwLb1O1m3dCMNjqvDkInx+R9JHFwkbXHxOCKc4suP/oE5G3uSaSyLKrphk+qrRMVAA7YVLvGcTzMqkqsJ8EuTAjuA5Ti8OmBiqSixFISk30vKc0wnZX1l0WUa72/5DIHmObyadFf5BAWWL6qijPQ4yFLi/LGKmMqgAli8ZyN3//xl1JVprM7ezR9XKXrIhuw9ytKb0h2WF+f/zOQly7FRQZaKpJJdqB4OVdLTlEMclcU9Z/Va1u7KoucZJ9HjtBO54r43eDtrEwKoX6MSAzuetV+/gwqVMhg+6ur96lsUXe7qxKjrIxzl/NxCuje4hd5PdOOcq4ufX+dBF9N50MXFHk/i4ONAVVFK4t+HRpWq8MHlXen5yRRywyrXQQhBQId0v89xVmUUR1ZEUj00FIc4mj3gB2k4DrCpjgk30OyYwO7nnEjfUVPIyQtFwhlCIHWHJyxsjNyw6qcLVdHOUJ2lBM1wpCaKqA8BEYcYQAoatapLv4e7AKiqcnZkskbIoN9JQ1jzi4qWV6lVicwtWd7xStXjyzG/ctdEXl36NE98MYzl837jno6PEioIk5KewsAXe3sO8b7i3G5tOLdbm/3qWxR1j6nFpt9UkMIf8PFsn7FUqlaBkbMfIC0jsZxaIOBnzE+PH5DzJ7H/SNrixDgi6BPrsj8gx1xKQEhShI0mJJqAVVlv07a6qvTjrnQFhIr+ao62pIXmJNspp1gIiY5aelAJesp51RynOmxrbAuFGLpiOCT4o4umWbgQQqALjQLDR04oQKHhR9qxUnGmJRj443TyzXDMWLaE+uNH0njCU1i2pcInpgBbIII6by9ZFslpkZBlRaR8MgsKnYHwDL1pQ5ojsJmdX8jOPXmYlo1h2azZkolRSoH3g4kO17XjyVnDuKz/haSWSWHb2h3s2LiLEV1Hs/rnNSUP8A/iwc5Pcln5Hjzec/ShnsohR1IGKIlb5nxErjTBjwrJaJLvtv1Jqs9PjYx0pLvYpoH0SdBBumHfqFLLwvFwbYHnLHt/NZpyoqUF4z+dz4JVsStJbj5HNNXCG1Q40eegpRxi3ZlQlDEWhkXH44fFkjCk5IsJ39GxWj9uv3gkDaOqaUopsUKG5xADMQ4xQNb2vXH3Kr1sxKlc9s1KwkGVOxEqCDH/k/iCHIcC45Y/ww2PdaV9j7YYYZOdGzNZ9fMarql186GeWgyysnK5ulYfOle5ntULD69nxKFA0hYXjyPCKV6xWyUiuJFXTdqYUmNx1mg+2nAFIL1objQ5QiIdzrGMGFLpJt3ZcRm/AoGNhmVrSKlcUSdp2XNgQ6ag0NRjCmxICceVbUbI8GPYfifJTsOywLCgMKgTCiulCVu6kQsFK+RqINuc9854CGtgas7PWKpHIoZbCppacjQgsBfKhnwICzZsy6JsegpVK5RB1zSlK1yzMv5SalkebJx4XksGvtA7JnkO4PPxXx2iGcWjb6u7+GH6Qgpzg8x56zuGtH+45E7/aShufmk+Sfw34WoTe5QIZ3/9saPYUuBo90Yn4HnUCek9rWTUS7yIrcEUF4cwbEdC0oGXZydRxTyKTlAINMNGl66fLLADjvNtWhA2EE7ARASKLLSaKvq9cv4avpnyI2gaaFqpZCeFFt+mTovarF26gezMHI5t04xAqqJgpKSncHLHE+LaHwpomka3ezqTXi49Zn9BbuEhmlFiXF2lF1nb9pCblc+AU+4hLy9eJ/rIQtIWF4cjgj6hCT82EefJwOfRKHShZHYS5UTogIEggIlJCpaUmBIM/CozUwpHxSKSPmdKgSHdsiCKtKCqtgkKTB9BWyWZuecTAgxTUMGXEWXbhXcwFPTH7NM0ePnUq9gezOPVXxay0YrS0pSRinTeip/Ln3NHCeNt6EHwW2Dnu5WeIFxoctGDb5Bh6ZzXugnj7+nKpFmL0DWN7h1O2oe7/s8gkOYnXBhRn2h3ZcmZ3f8U1i7dGLP9y5zlxbQ8cnAklg1Nohh4Bk8o3oNPguFsR+cju3bMJxWP2HKOJyjzHP1Tk04EWVN0CWxUoQ0h0MPqCWBLgQxIdFeeDUn1auXYumVvVORZB91ChGIDISItheem9mfzukxG3fxa5ICh7JGnKa9pYJWwwiYgJT1AqCCyEvjFuK+YPfFrfD4fj316L8M/HML303/muDbHcM41Z/71eP8w2nQ5jY9e/MLb9qf4/6L1P4twOF7zedJDH3LzqOsOwWwOHyRtcWIcEa8BZ9Z4A8DVb49NlhMCXViejQ3LCJ/XtX+aBseUOxFDlsFARWxdypshdQypY0odU6oosSXx1CpcvnDY0im0/Ni2wHIk1SSCkOXHwse0LctJF2lYliqFDBLDiI/u2oag1+zp3PvdbCq4VdeiHyAuBJxVtw4Bn6640YZAKwRNCppUrIQ/W4nYh/NtzyF2+yEkobDJ7AWrsWybW7u0pX/ns9i7M4cLWg/3PnO//GedvCVzf2XqUzNYu3SDt+/N31+gap3KpJVNpddjXWl1bsviB4hCOBje5+zwfYU/Jfads0yRaMqRhmTGcxLn13GSdB2bFflNKwkK6dpdtzSzC9ec+uD93tdEuMZugjJOX+fjVp2TTkKe7VMRY6kJr0iIGwlGCOxIjjS7jVCMzy0sG82SSD3qcSkldmGIQZ3HMGrwu9RpWsPZLaFIZFgIQfPTm6DpGkKPHEvLSKVWY6efJWMcYhdmyCKYH2L8/e/QusPxDHrpJs7teha3tx1Ge+1K2mtXcmHgwORqlBahwhCfvDKLj1/+ksJ8Rcc7vl0Lej/ejbSyqVStXYnxq0tHF7NtG6MUkpp/B4FAvNrRWZ1PPajnPNyRtMXF44hwiiukNqFTwyW0qTken9Dxu6KWHiVCJb+5jqpyZMGUEadm2d4lmET+8epOm2i1ChCEbD9S6k7ynYYllc6xhSrLbDjOsyk1TDtCoQgZOllhE8vWMS2dvHwfYSOAtAWmqaGZfk4oVw8j6POoHkt2b2dC+yupnVYOzXB/leq6Mnx+BrY6HX+uQM8TpEkfZfx+0v1+2jduFPuOGPWOIKWTDWjayJCNP+pBMKD7uJj7+sR9HxyA307p8M3UH7n/0sd5477JDDrzfs8xrlqrMpM3jmVG9lt0vadzieMU5BbS/+ShXJLRnV7HDGLPjngu34HC21te9ZZFNV1jyo5xJfT47yO5ZHdk4/ULOrPxxsF0atIE4Y+qxuEtneFReFXAODo0qz5dXn/X0zFGA8sXTw1WXGSnjS6Rmkqig8hDL/qVWLpJFzYU7gkj/Rr4NGxNIGyQuoYM+JB+jTqNjkKzlD6xGz3ZvruQGx/sjC5AiNi/3ysGXkiNhtWwbfW08KX4SEkPUK9FHYxQKRxCAT5/7Av2iu9Xe98t0+aZPi8X7XXQMKT9w4y9401euWsid53zoBdcuGboFczIfovJm16hWgkKFACLZi2lU7nruCSjO6/dM+mgzvnygRd631u2a06L05se1PP9G5C0xYlxRF3xD9tuQEqDVM0kjTAaJrZ0xdmVRrBKqwsQlD6vmp1paxgShBN+kFJFj4N2iscNdmFHyasJIGz5yAkHKDQ1wh65TVl3iUbQ0MkNpkRFlpV8m65HHG0hIGjY/Lxja9w1SSQfX9GTc+ocTYOKFXm03fls6H8Xv958K/2nzCDsLNsVGiZt69bjnrZt6H3WSQSiuMHRCSfVK2RQLhtS90p8WSZX9nqV7Ox89u7Nw7KKrlceWLz/7Mc82HkkqxfFJ0LMmTSPUEEY07AwwyYLvliyX+f45JWZrP/1T6Qt2bZuB+88/uHfnXaxqFSpLDPNKcyyp/Kl8V7CiMWRBPXimUzuONLx0bqVzNiwSvHTAraiTbhxWZ+Tv+FXyXJ+oXmRXWmrj607HycqXK1CmZgnmcsXFt7Lvgp0uGPYUf63+uKQziwVFVbHHCOuCS9RGSHA52PT+t1Yvlgn1Qhb/O+W9jw0aQB1m9WkRbtjeWPFM3wZnES7Lqfy1aR5impnSWzTovNtFzPghV5cPaRTsffp6BPrOxekVslG9XqRXZszMR3ucjQyt+wp1b0vDfKy83i8+2hG3zIOqwjtI1gQYtX8NYQKw4QKw6xbupH87IJiRvprjLz+RYIFIWzTZtrzn7H5jwNb5Cka/Uf3ZpY9lVn2VJ6e+9BBO8+/BUlbXDyOCE5xgbGDHza3ByRSOL9oAbqUGFiAjo6FKXUkGtXTjiGYv4WwzENKyLdTcMwkAlWaucBwXGSpoTmk3UI7cjuV5rtGvhlwnGY3bBFBk4zazN8Rm4Uc3T92hxrClY5zR1yzYzd9pn5Eqs/H/BtvJC0tkrEcilaKkPDVsrXMXbyWid8uZs6wPkz8ZhFzF//Ouu17QUC/jqfSt+MZtL1slPfACIcM/nfh0+imJDXNh1UQcYzPv6R0VIXS4L6LH+Pnz5Wj+8P0BVStW5m2/zuNvk9fD0CLs5qyaPYyQgUhfAEfjU9s8BejFQ/bsr3IhpTxFaKSOHhQnPsj6j08iSJ4aOGXjP9tEZ4t1FDkXx8QcoUjlWOs64K7z2zLozO/iUSCpddE/bRhZ1Z+JOHOjTBrke/glnYG4XNWBg08Z1vTBD47cV5JsXBX0JxOx53SgL5tH2bTmu20atOUx94b5DXdvTXWYbUtyTsjpvHOiGnc9kofnpw1jPmfLuajl77AClv4U3y8s/013hjyFmsXb/D6zXzza2a++TWgqFlGKOIcD5921z5MvniEw2H+V6UXtlPy+rNxs6nXvDa3vdKH5qc1JSUtoOTkNu9GAuWqlCO9XGLptZJgR0nWCZRtTuKfQdIWF48j4q58v/k8bAyklE5BDOXg+oREoDjAptSVNBqSrQVLMGQ2Iekj5FAo3MivgiTPSsGwdQzbR9D2U2AHsKWGT5PYtpJmK7ScSnUOx0wXEVHgzrXP4KxKrR194gh/wVOqsNW2FdawCnxg6WBCx1rN6FCnMVc0bM4zp17E41/Pw7Il+WGDY1+KXUK78YyocuU2CMeGbty5l+nzlrNo/nq2rN5DSrYkNUfStU2r+JsnnQcRECw0ueOBSzm3Y0uefaMXg4eXTFeIRk5WLn1bDebySj15ZfDEmGMLvlwas71r024+ePZTRt6g9Ii73HEp3Yd14dSLT+T2V2/mpPbH79O5XVzcpz01j66GL+Cjcs2KdL2nZMH7JA4ckkt2Ry42Zu9mwh+LYp86rlGVIHXH/jkRYEuDh76bi61F660V6edCA+l3lCac+IPlOsa29Ip5uKbW9inHuXz5NB6+7WJHsxjQNGzNXT2TqpodilYmDFMpUCARUnLNgPM5/oxG3DCkI6t+WMnG1duQlmTx16vof95j3tTO6HQyFY4ql/CejBv6Nnt2ZTPt+c+wwiqIcXSrBpQvX4aMihnF3kszbHHbK3247JYL+DQ4aZ9Xoea+9z1dqvWmW72+rFoQWZn7ftrPnkMMylFdv3wTg864n6ztexBC8Oy3D3NOtzacffWZPPfdI2ja/v17vX3szQRSA/j8Oh1uOIe6zWrt1zhJ7B+StjgxxMFONjqYaN26tVy4cGGJ7Watb4qGqkgXlAHPSbUl5NmpBG0ftkOVcHnCIVsn105HSoHhcI2lFN4b1s6wa+SE18ddbtgdSvd4ytFV6UxbSa01KFONt06/k57fvsmCrA3ePKWEcFg50iCxgjpeBoiUar0wrCEkXNn0WD5auhITYh4sa++8I+baV+3YxW/bdnL/pJnqeWCCP1eVMxVOMopwTn5e68Y8futlvDLhWyZ9MB+kRM81CORHIhK1zTw2OXzem568lqsGX17q31fvFrd5Qu8Ad799K+c5IvKXlO1OqIi8GkB6uTQ+2jsxbv/fgZSS3Kw8MiqWiTHoHzz3CVvX7uDqwZeVWJXpQOCN+99h6tMzSE1P4emvh7Px183MnPg1x7drwTV3H77OuhBikZSydcktY1Gp2VHyvDf+V6q27585dr/OkcShQWls8f3zP+PdjUpf1wy6pGAiEV5bQxpFFHQsECEQUiBsoV7spbNu50hJ6maUjyzVPiFBBJ38PAl6SD3n3Bd8EVbHRgy8hPNOaUK7S0ZGqVdIRNhGN5Tzi2WjBc2oc0hE2EKYFikBHyMm3MidFz4Zd72f74gEKUzT5McZC5kz+Tu++3B+iffzS/M9pJRcXbMP2btyErbRfRqWaeNP8fFRzkT8/tIpPuzZuZerqt/kbfsDPj4LvgPAn79vpVezQQn79RnVgyvv/HvVSIsiHAxjhAzKlC/j7du1eTfvPjmdGg2Oossdlx7Q8yWcQzhMn5Z3sX39Tlqc0ZQnZw1jzIDXydySxXUPXkmT1o0O+hz2F0lbfODxn38NWLLtJmUYBfgc8TQvuc2ph6y7qcoObCkISp/aKyQ+LGwpsSRkmylkGWnOGFHhCuflIifkj4lGCyGxJVgShJVGTkEKS3bl8P3232lesYa3ZCdltGqPs9OOGt/NaLYUL27Kyl8JR8tGFPNuU8GfwshJc/CFlEPsK3AcYvCUJlx8+/Vqfl21hZt7tuXbGYP59uMh1IuKVvht03OIAcYN3bfkiB0bdsVsL/92pfd9zI8jPB3OaNRrUWefzlEaCCEoV7lsjEM85PyHGHvHBGa8+AU9jh7Anp0HLwEPYOk3K3hnxIeYIZO8Pfn0bTWEEdeOZuGXS3n93sm8MOC1kgf5l8FVfinNJ4n/HlyHWAjQ/G51IudglC2Vjg6wpw3vJM1JTSKdpDrpvNSLBHbPtalaVHTYCkQi0H4EPinRLMlTr80CIBCtOSxQBhuQQiD0BI9JwwDTIlQQ4s4uY+KPF4HP5+O3n9fw/fSfS2wL0KNhf3Rd5/0drzPLnsrkTbGrgK5DDGCETLrXu6VU4wKsX74pZtsIR4IedZrU5NJbLoiPxAMnX3DgtZEDqYEYh3hvZg49Gt7CjBe/UIl85w4/4Ocsir4nDGbL79uwDItl36ykS5VefPrqbOZ/upgBp97Lzk27Sh7kX4akLS4e/3mnODu8JFK0Q4N0EVJaw7aiTIBEx3bUJgSGrZFrpxCSSnoNKci1UgjbfvaYZcg3UwnbARUFJmKAqwZqcGGVyynji10mMy2NQsOPzyxDVkhDOre878+TGHrcBTQtVw3bFs5HRwgYcfJFrL36fh45rYMzivPwCKsLES4lQ00/6sESOe8rs35i6MRPuWD46xQ43DPNIoH8GmBL9KBylse/94N3eNq4rzn79KN5+Z0+jHnrJtq0OOrv/Co4vVPsy+ZFN57nfa9/bF0+LZjMF8a7HHNaY3wBHw2Or8ez3/4zBS+WfL3C+25bNl+9Pe+gnu/Hj2OjatKOfbrP++Cng3r+Q4VkcseRCzcBGZT0rwhYMV6tRKqkO4eqJhxZNqEJlYDncIiFEMrhFSB9YPtjYwLXt2lFz7NauYN6J5dCIAWUQffy+vbmBel480uMGdkVn99JPrZBBHREGT9ffXMvs769j9RUx2l2Db5VxBsvQl849cJjAdi+aRdP9X6RHo37M3XkR3H/zovDzk2ZbFmrEs+yM7OZPOJDHv54CE98eT/TssbHJT1nZyaOJifCsWc2wx/1ElClduWY47eOuZFZ1lTG/PQ4GRXSCaT6uenJ7tQ/tm6pz7G/mPvOdzF5HsuiAicHC9uLBGvycyKFR6SUfP/RgoM+h0OBpC1OjP98ol2jCveyes/dgENPwIcmBBLJqVXv4fud48m1czFRtAULEXGIcQnpPhCKNmF7gpnKiNuAjzTW5YdYm/81wvZTaKrbqmMTtJSx3GubQDzva/p5/ZixfgUPL55Jjh2kcUZVfty0lZcXLqZfy1MYf34XHp4/h4blKvL1mo1YrpVP4AwvvXUAAK2GjMa0bI9DLITTxrbRC0FYEs1ZdrQ10CzpvQ9Wq6qc+ksb3obpFMV47/kv+XzzC/R+siuz3/7Wm3uiKkx/hfsm307jVg35fdE6Og+6KOGylK7rPP/DiH0a90CgTLk08vZGsqibtG54UM93Wb8OfPDMJ962P9WPEYzIMzU+6eCe/1BA0TuPPCObhEKK0AhJOxLJ1UAGbALoDD/hAob+8KXjBDsdrCgqhRsE8IG0pFOt07FtmoomCwvSNR9TflqOJgSariLKKuKhHGkJ5IQMouty7s0tpGmjGsyYNIDnxszkm+9W4wPOOr0Rt/R6DSEE7866m5ee/JiVyzbT6OijmDd9UezFuZJEUtK8dQOGT+jPj58u5IFL42kVpUWFquX57efV3Hra/QB8MnYWJ5x7LKNmP8gJZ7dgydzIi3ybLqUvWhRIDfD2hpd47e5JpJdLp89TPRK2a3pKI6ZlTdjv+e8PmpwYa/eiS10fLLTucDw/zogEKVLLpMRUSj2+XfODPod/GklbXDz+85HiWuWvoGG5wYCffC8CDH4tg12F68k283DZYlKiOGQOZHSUQQqHZhFBqpbCpFNfJ2RXJGgbFJoGmWELV1ZN6RyrcKzmeaYRbM7LotnkkQz6fgaZBUHChYJfd2Qx7Y+VrN+zhyHffMnQr2fyVefevN6hC4+36YCwRWSYKInL7/v2ISMQYFPmXkw3ihDzN6+qNmkWaAicdwBFpRBqfg3qVuaOPu1Zt3Kz5xADYNlMG/c1VWpUYcz8EVStU5mjW9Xn08IIfeKHGT+XKrp51eBO3P/u7TQ/zHQin533KJVrViQlPYVu9/2Plm1bFNs2Ly+Pl28fz7JvVxTbpiTUPLoGT80dTsOW9Tipw/FM3/smnQddRKUaFTj14hN5aPqQ/R77cEYyOnHk4tcu99KgTGU0IdCd4IIQUC0jgwcWzEboSt3Ho1WIKAqFoyGMQDnHUQrGUsD9l57Dmzd0wSc1QoZJYb7haR3HCP9IJ8kual7lM1J554MfuajLaGZ+/RvhsElhbpg5n/zK7yu28vvyLXQ6+3FatKrPG9Nu5d6nrqFcudRIVnQU961qnUo8/clgAEb2KJlWURRCF+h+nT6jelCmXDp3touVD1sy51cARn01nEv6tqdS9QpcOfgy7pt8GwDZWbl89OLn/Pl7vHxnNCpVr8iQNwcw4PleBAKHT/W5Fmc2o8cDXUgtk0KlGhV5dt4jf9n+lznLePn28Qmr1pUWD08fyuUDO1KveW36jOrB+NXP06hVA6rUrsSdr/ejYcv6+z324YykLU6MIyLRDiDf2MaincPJCi7DljZSpLAtHMBwPEfbhjw7BRtVcEN3fM9cMwXbKbyRb/gIy4BiVQB3NRnEs6s+YXNQLb9YFhjST7SShGEpi2xLCJuOJ2pDfoEPKXW80nhOexnSwYrQJCSSISe3of+Jp3HD+x/w7YaN3jVVLZPOT/36xlxnZnYB5zz8itqQKnqC4+yn7paRtyAp0cJqibJsegqfTxrojTHlhS8ZP2JGzLjD3uzDGRckVnzoVr8fuzZlAlCxegWmbP3rIhXvP/sxkx/7kOPaNqNe87p8M+UHTjy/JYNeuukv+x0OWLtsA31PGOxttzizKc/Ne/QQzuifx/4md5RvVk2e9Wrpqm991u6FIyq549+O0tpiKSWzt/7OnfM/ImSagOCYctVYssNZwrZRL/u2pooIuXkVNghLqBd6CRSA7tjNMn4/826/idPue8mhg4Hu+EjeI92W6G7wz4IUC6QpVZCg0EJYbkBEgC3RwhZ6oSrQEe0WzPz5AQAuanB7jIRbv4c6c1nPNjHXek3tPnFybCWhqJJEB99VcZSLWfbUhH3XLd/AzcdHbFPvx7txzdC/TtgdePq9bF27ndte7cMHT39C7u48bn35Jo5vV3xQ4HBB31Z3sXZp5Hk4/vfnqd2oxiFKuXTFAAAgAElEQVSc0T+PpC0+8PjPR4oBskNrmPnnlewOrSQobbJsP3tMm4AWxhWzzLdTMaUPS+qAqjhn2LpDl5AYtkaenUbQ1ikw/RSafn7YvoY/CzNVVNjSHIc4FpatETY1CkI+wqaG30olvzCAdBfwYrXePERnYH+/Rf3Db9cgVpv35FrxEjZVyqfToGoFdxBqHVWOeSP60r318e5wkRC4k3A3clistNqpHWL1h4WuFesQZ2fleg4xwJ7te/lz9ZaEbQFevfttXrlzIrlZefwwfSHvjPiQrWu288nYmTzc5ali+x0uGHJeLMc5urJUEiVAEqnmWMInif8mRi7/isELpiE0G8uWGKbN0t3b1RIWRDLjBGo1yydVZNjZJaVEhB2HWKqX+gaVK3LasJe8XD3NUnQKt2w0KEUK5XBLdFNiWZIM3YcI254d9AjPEYXMGEQHkCpWjc0dOeHMJnHtX1kyKmb79tf6MiNnIr5AYtaiL8UXJ612xuUnx2yffXXxNImnbngpZvvNB94rti3AhYGrWTX/D3Iyc3m489Os+H41m1Zt4a5zhrPjX5BcFu0QAwz+B5Ly/jNI2uJi8Z/nFANsyPkMUyryfKFTiAOhIgN+YWFIDQMdt7KRuyJmSB1dKIc4y8hwKBFq2U9K+HjnVwih+Mcqac+N+EpStRTqpzTgx/yN3n5NQHbI9myvZ2OlVPWWLCKKEAbKomuQrilDef1JJ5IdDDJ95W+cWKsmoy68IOH1zrj7hrh9g3uexynH1ePFyd+SkRLgkrbNWbs2k97dz6BSuVg9zHpNa/DIpFt466lPOapWRQa/0BOAd56cxoRh76H5NB75aCgntT+eQFo8Tzo3K7fY38W0Zz8p9tjPXyauUiel5M1h7/LlhK9peFw97p08iIwKZRK2PdhIpJCRROmQ5LElMWndAoKW6WixRygUaE6yqR3lmLo/HX9Z6iDCAs0WKj/PUZdYuWWn8pudKLHX3RnjyjNbMv2zpc5+AZpE2pKCvLDXTkrPeqtOFkhN5V+4JfAEEAyGSU0N8PLMITzS5w32ZuZx/dCLqduoWty1lq9SPmFU9/PgOzzd+yUWzV7GiecfR8UaFahYrQKdB14c1/aBKXfy0m1vsvLH1VzY61wu66ds/g3HDGLLmm3UbFiN11Y8i8/nwzRjq8+VVAzjrwoXzZrwNd2HXRm3P3PLbh675jl2bNzF1UM70al/x788xz+JlPSUQz2Ffw2Strh4HBFO8R857yqjJ3A1I4g4sIrrqyGdhGK1P2hr5FmKTpEqlCMdLU8iHFquWqVzSoh64wpyDZNMcrxtnHZOb5U57eyT4DjEGht7D+G4sc+TZ4UVfcKGumXLe+cddOYZDDrzjH2+BxPf+o5vvlvNrT3O4qyzSubztj63Ba3PjSyhbVmzjTfumQyAZVrcfcGjzLKnkpaWgu7XsYyIQR505jB8AR/jV42mev1YxYr0Cunk7ErsNNdrXjvh/p8/W8yHoz8lmB8ie1cOY++cwF2vl16C6EBi3G9Pc0W5yEvHZbckfjFJIjGShvjIxYo9Wwla8SWKi4VrTq0IdeLEGjVYunG75xC7sDWVHxHXX8KMn1YUCfy6XrDzDPABhoxEjG04+pgaPPZgZ3pc8mx0L1JTVRCgXIUyjJoykH2FYRjc0+FRhCaYsOaFErWFNU1jwPO9Yvb1az2EzasVZ3jLH9vpd+IQxi17hp6PdGV4p0hin7Ql7bUraX5aY0bvY/LyaZcmXi1/4roXWPnT79iWzbihb9PizGY0OqFBwrYHG+d0O4u5k7/ztl9ddvivNB5OSNrixDgiYuOGHfbk01JE2DOQKVoGvRpO49RKNxG0NVz2mCkFhXaaU9BDIygN0jU9LglPasLTOPYJ09HXBMtWiXZ/Frq0Alnk/6pdJMtanadKShpnjn+VvHAY130XCLILgzHX881v67j97U94be4CrKhSmRu37+Hj71awdktmTPuBt73F+Le+Z936TIY9PJ33p8Vz/2a+8z0dq/WjY7V+XFK7f9zxb/8iia7/c/GRaTNs0uuY2+L2T970cszTrP5xdfCn+mnUqgHP//BYXHuAzC1ZHq/ODJvs2HjolvYyMjKYZU/1PgPH3HjI5vJvg6R0iR1JY/3fxBPLZnuOqgA0X8R29WhyIh9ddB0V9TIqWuyaWgs0xyGWwOLt27w+MUxbn9PN+UQKgkAoZGH5o4eNeNTeYp1fIKTDMQaObVKdHlc8Dz5NfRxER2NDhWHeHPERj/d5jZUL1kbmJSXzP13EnMnzKMyPtd0XpXRj6TcrWTJ3BReldkt4n65rPID22pW0167kwc7x6hWbVm6O2d78u7onZ1xyEjUbVY9rv/KnP5j4UHzEumtUgSA9oFGuSllS0lO46cnuxTq6mX/u9iLQmq6Tte3g6rn/Fe59e1CMLd7Xqn5HMpK2uHgcEZFiCw1TuslrEr9I55qGHxLQMzBtg++yvkIIDStGhs21rM4+UQCkIG0bE59yfqWGpoFtQcj2K61hqTSHTacKnhAWoGM7Tl2DchVZvzdbjSlBWirxToR1MvNCYIe9inuuxe58TCRie+vEGXy1QhngOSvWUGgYDOxwBqs27OCmx99DCIGUkufv7EyrJiry+uvK2Ezk8RPm0eWK2EjAs7e9Hblfhk3/cx/jxTn3efva9zzbixQ7N9JDMD+Ez69jGrHLd0bIoChSUlKYZSVOFCkOZ15xChOHT1ERadOOMeZJ/Lsgj0Ajm4RCzbTIipdEBWqvbHgcT56mqpYt2rGFPUHXiXSiubZrk6WiPjgLb9KNIDu8YgFIP5DvdLciUV8hwdadFUEJugG6rpGeqlEYNHFLjtq6IOATWAUmn3ywSJ3KLUeqCTLKpODzqVyQwsIwVzcfghG2QEp++GIpr303nGp1K/N8/9c86cpJj33IK0tG4fP7+GXur7E3RML6XzfS4Nh63q5v3/+BbWt3eNs/TI8PYBx/dgsWfBGhmh17VjN1x4QgmBeMaw+wePZSrnswlg7Ra0Q3eo1I7JgXh2uHdWF031fRfTqVa1ak5X9QruxIQdIWJ8Z/3ikuNLOI0lxASsizCnnx9yuQUhCSPiyp4UPHkOp25JkBp4cELCx0QpYPQ0psVIEPENheARDwayYh2xdxiJ0/OJ8Oli0RQmCaOtsKs+nZ+CQm/L4Y282uNgTSjOLTRUErEDz2+Vxy94bIzCsAE4SpohmmkCxcp6IGsxf8TjCqMtGn362kVZPafDU3Xvy8Yvn0Eu/bzi1ZMdtVqlfksc/uYeR1Y/CnBmKKaoRDoTiHGKB+i8R0iH1FharleWPVaFYvWEvNo6vFUTJcZG7LJHd3fsxDJonDC0dihaQkFHLNiParG3J474/lvPf7Ci+qi19z8ilwFCfAzUmWlnQUeRQ0lEOsjjlOcArYhrMK55Z/djjLIJCWxHLoa41a1MDMMVi5epuSptQEZr4VVyXPDY3k5QZ57qFpzHpvAbZhOmVKndVFCzas2kq1upWZ/dY3ns7trj8z2fTbFhq2rMcbCSqAVmsYW05+8exf49oUxYjP7uOhLk/xy5zlHNemOY98NNQ7Fgomlia74bGuJY5bGrTv0Y5mpzQic0sWzU9vQkpaYh7vyp9WU79lHdLTS37WJHFokLTFifGfd4r9WmwSmUQQItVLcksRJoX4SNUU7UHHj4UvJhmucVoTlhgbSNXVmpxuGfyfvTOP96H6//jzzMxnuYt7r4vsSyKSiCTS+i2hCBVKm7Qi+UrRvmih9C2lVQtSWpBCVCqVNkuUyp712i7uvnyWmXN+f8x8tru4lx9FPi+PT31m5syZmfOZ+573vM/r/Xr7LN2WZwNsHWLQNYUMVWGK2l8piZS2rFtxwOKtNcuJCbXa9aSdJ0Xs1KFQgr8ysiNuve58nChJjSRb3Pz4OtXwug18AROv26BJ/eoAjHn605jr1wRMeiOWowaQUi2ZvH0F4eXBY0vLtbTv2pYZmW+VWj/lodjIb0Kyl0692zNqSuU4dw9cOoaMdTu57Znr6dD9tDLbJKUk0vaCU8rt4/oTb2fHBjvCYrh05vvfr/C4gUCADcs30aTt8cf01FteVj4vDHmDnX/tot/IXpxzAIUADgRKHVoemxCiK/A89l/EG0qpsSW2e4C3gdOAfUA/pdTmQ3YCcRwQGidHKqcpBWbACfuGbgkdMLGfSiZU0dwUhj1be3vzxGqs25sFLltvWAZs+bVwSSUBuBzKsCNHSWi9puzcDQ0sCcv/zLArfHqFrUoRBCUUyhBIXcdVaDpax8LW7AQ+m7Y4olTh9UJRcdjYN2tjv4zXaVKLzX9sQ1oSpRTV66XzxZSFrFm2IWY8Tu96aimncfALA/h04oIKx/LhGXeVWvf9rMUURhUgAqh7Ym1ue+Z6Wu9Hdz2ENUs38PT1L5J2XApPf/kQhlG2e1C/WV3qNyutfASQm1vIFVUHhJfPu7JTWEN5f9izfR+F2YV/S9W8IxnLv1zJpAffp+pxqdzx8k1Ur1ut4p0OAnFbXD7+9ZxiQ3Pj0aqGl0OUMCFEjAIP2IOhlUzJEIq1BVts2+1scukWCYbE0Kzw3kI4DGBhO94hBYtQz1LpCA2kFVGpCB/K0kIHIyTD6VCVY5qFF7TIukV/bgHg4jNPYkD39rQ4viZXdW5LnwvsOvVSxmaf3HdPjzKTOz5YNY7zLjudqrVS0evW4Nkn5/Hl7OWl2pWFklrXDVrUq7RDfMVxA1k8dznb1+3kwUvH8ttBFsQIOcQAZtDivbGz9tt+7ZINXOK9mmFnPsAl3qv5ZcFvB3XcfwOeHvAS33+0mHXLNvL0gBfZsjqj4p0OCgJLapX6VNiTEDrwEtANaAFcJYQoOZd7I5CtlGoCPAccfHmxOP7fuPHEDjF2UUX/ztFGzvGVC4ORma9QPY91+7IiucsCm0vsLcEvJhJfiF3pCF0aoHQViQgLgXQJhJKgO4Ze1whWcSE9GpZbw3KJUn0BdhU757vPidI+PudeOnQ/jZZnNefJefeTkl6FvSX0ig2XzpPz7qck3G43H+x4jbon1ia5ahK6S+fK+rcSDJamopXE+l/+KrVu8poXyg00RGNPxl6GnnEv29Zs5/fvVtMz5boK9ykLd3Z6IGb5m/d/qHCfB3uOpX/927i51QiuqHnjQR3334CsXdk81Otp1ixez+J5y3m497iKdzpoxG1xeTiinGIhxFtCiEwhRMVzSAeAdE+zSEKFFirwqSLGGYWl7HJJkiAJIjR/p5zkZz+xZtd2fl2aFW4HtnKPpqmYtkqBtLSwDS3h4nL3aec6XLkSRlfaUWKFQmpRh4mKgAgFAYe3K4Tgxh4duKB1E775cS2Pv/oZUkouurBluMvU1ATOPbt5ueM06pWBZOHCtBTBgMUzD85i757cUu0yd+Vwfc/n6Xn2k7zxwgJOODWWrnDHARThyN0bq0Qx+cGKI7yHAqOv/F/M8phrX/hbjnskYuuqjLB6iG7o7Nq4u4I9Dh5KiUp9KoH2wAal1EalVAB4H+hZok1PYIrzfQZwgRAl/9DiKAuHwxYnu72EvFkpQwQKIh6vAoRCWbYij+WWSCEj9Y1EWKsn6kSjt0UCCgpHVaL0hYWDDzGrNcHIIV0pvcFur3Q9fDg7aVvZwYDQQ0QIfvrSpqrVqFeNkVNux1ujKi+Mep/v5/xCr6Hd8CZFqAZ97r603HFKr5XOGd3aUJBdiBW02Lc9i15pA8ps+/HrC7m86QiuPvVe2vdqH7MtqRI0uRDeeWxGzHLAV7ETfqjw85xIyezcPXl8PW3R33bsIwl7MrLQNPv+k5Zkx4Zdh/V4cVtcNo4opxiYDHQ91J2eV2csOgk2BxgdN3bRDiEkpgIDhUJHc0IHSYafROFHoBACEnQTLcqJtpRm515gJ+7ZKXUWuiZxCcGzp/Wjiu5FIAhadoW8MIQVfgjoSjBr9Sra160b4/SGZgwNBeedcDwd69W1fyhlyw5pjs8ugiBNmL9sNQAff7WSV97/nm07c/hs0WrufW4299x9Ca+8cC2jH+rNjPduxzBK/+TT3vuJLhePo0ev/1FS1Wj+zF9KtR824A12bc/GVxxg+ts/cP34mxg4pj/tL27Dm6vHl6pfvz8ILfbvos1/WpXTcv+oE6UTarj0CpPxdC12HDTtiPz7/FvQ8/aueJM8eJO9JCR7w4k7hxqKAyotWl0IsSzqc0uJ7uoC26KWM5x1ZbZRSplALnB45iP/fZjMIbbFLk3nufa9bDuqQDMg/HaPBCUidAVhG1iV4FAaHGfY8jjfwyWWAQFStyPDUrcn3qQOzRtUZ0iPjuia4wQ7fp4C0DUsF1iOakVyFS/zf1uHpotI36ZyVIYgIcXLZf07oNeognLp4DYQemjGT4DbxetPzQtf66BzRrPi2zVsW7eTx294jd1bs5i5bxIPvD+c134dx8DHSye4mabJbec9Ro8GdzB70ncx2wLFpbnCW9ft5LWHZlBU4CNrdx73932JWVmT6NSrPb2GduPj7Cml9ikP7S9uW+m2+8OzP8RW9zzvyk4H3Ifu0itu9C/E8ac0oFrddLzJXrxJHrrddMFhO1bcFpePI4pTrJT6TgjR6FD3a2herm66EIDX1p5rq+wQtAt0CNt5tZyySaFk4+hggqZBsuEj3/RQbLnDyR6Gpkh0mQQtjYClY9tei+fWzmHEyV14YMXcEBUNpRSWKcDSw861KRXr8/axXu6jcUo6m/fmOlqZdthDAk9d0oUez01BORnWSR43/vxATDxjb57NI/theez02W+OlmXz5nUoz835c1UGb7z1LQDBoIVI9aDlRhJiLupZ2ljmluCtrfl9OzeM6k33+au5aYDNOe5+WRvuuLt7eT9JGM9++ygjzn8EaUpadGhaKkO6spiy7kX27txL9u58mlZCN3P0x6O4ufWIcLDqkY/u3v8O/2Jc/t/uNGt3Aplb99Ku66kkpR6mwigxlKIKsbeC0qJlvcWUNYteUZs4ysDhssXdG7ake8OW/PfHT5i95U/bMY7ybwHb8JVQ4AkFlZRuO8aiGHQpwjxi5bV5wkIBLpuavLYwm4Rd22jerCa/bd5lJ985vqVUgEcL35D7gn4Wr9pGUm0P2m4/llLg0kJ1Q2jb9njadmzC/Dm/EUj0oACvnkAwKooQXY55Twm6xLKv/+D4Fl04t2/5GvO3nfsE2zdm2n15ExA+Pypge/KGu7Sj+Nfv22KW/cUBktOSOfu2rox5fDazzrElLmfOGU5qBVHjTj3b07Hn6fz0yVKEJnjg/Yp5wGUhNTWJBXI6KxetpmGrBqRWwpZccM05fOWoddSoX41z+xy4Dv+/AW6Pi5eXjuXnuctJrV6FNvvJofl/I26Ly8UR5RRXBs5byi0ADRpUjpRvyiIWZfSi2NpJA3cSWwMuQCMo7QiFW1ikG0H80qBQ2lN8hmZFKik5P51bkxgigKUEhaadmGUpQVDqWGgOn1iSHcjl0ZUfAzpK6s40hE2jcK7B7lcjXMVuU14OmiOkGXoepHg9fPHHOhDY0Q4ELkPn5MZ1WLHRdnjdhk7/c23+8AUdmvH98o3h625/SgN8vgC7swuoXzMNTSsdJZ43f2XMsnLraLpAScW1gy+gZu003pn5M6+9ExFJr1MjmZydec61QNdebXnigRkE/JEBmztzOXOnL+ee0b34T9fyo78tO53E54H9lyOtLKrXrk712tUr1bZRywYssKaTsyeXtBqpFe/wL0fLs076W45zCDOeM4D6Ucv1gB3ltMkQQhhAKpBFHIcEB2OL52//g3uWzcJSkmSPiwK/nY8hTQFIhAHooIJaJNdCt5UnnIOiDFBV7ECD8CuMgBYOOIcCzQrwSYvFmzNwFTrOsg6W4xvqRUQ1VrZjrUNh0EIkCLw+EblTleKuEV15Yvx88j2g+wUew+A/XVuy4O0fwnKbF/SKBBBqN6rBDsfBBejQpRV7MvMwDI2q6bHJ3yHsjNJfF0KgV0nGzMomIdnL1K2vAnDpVS+Qm2vLrhkCvLoW1g0+voUdnBvz+OxwPwro3Xs8utfFgnn7f/EfPWvkfrcfCFqdXXl7cs/bQ7nzjVsJFAdITi17bI4VJCQncP5BRNcPBnFbXDaOOqdYKTURmAjQrl27Sr1prNg9imLL/o0UBdR31SVH5qA0my+cZSaiCR2vZiLxU2B5MQRU0f34LB0/rijdYdBRJOgBcoIJKCUceoSTcAcIzUIQm8wmTT3mvSg0hRhZAcplUyJCHQ08uS2PzVkYbnJSreq8dG1PaqVWYfhrn7Dw940Eghad75/I12MH0fXsFuQV+fh80WpaNq1Dq+a1Oe+mFwFI9LqZ/cJNJCd6Y86rxyWnMv+ziGMsNMG85aNj2rz2zveR8LlS7DAk53U+ifSkBC6/uiO161Zl9668yA6hBw3w1MMf79cpPlQoKCjGMARer7fixlGIO8R/H2wu5iEzxEuBpkKI44HtwJVAyTnp2cD1wE/AFcDXqmRWaBwHjYOxxXcvnYkM5WBoAbxuAxOF5gIrKJCWnZCMW6KKAaGhXLbTKqxI9DgcIfZAom5QVBiMMqcikmgXHQeIuvWUASrgaB9HX5MAWUXHDFi4nChwWmoi/Qe/RX6BDzwawepebul/Fpf17cDgu7rQ45JnCSrFvBWbqD/9J/r16ciLXz/As0OnsG9nFteO6slzzy7g99+2AnDRxa24+4HSnOJ6TWqydW2ER9rhktN4ePKt4eWvv1kVdogBTAWBNg3o1qQWx9VLp//w8kouC0xT8vyELxg29KJy2hw6FOQUkJx2YM6t2+0+phWA/m7EbXH5OOqc4oOBX2bGLOdIe2pLCIGuIFkPUCgTbJUdLUihZTtWOhKvJvFbLseJjYRxdU1hIAmGb6zI72tJcBsWAUtHCFuOLXQ8pTnTbFJAyMgHCQvTP3nRRTSpmka7+vW5cNwbMee9aV82tVKrALDw90hEOKvAx9MffsPH3/yOP2hLsj3Z41KuvXdquE2RL8ArH/7A3QNieUrNm9dhyOALePOtb/F6XLz84vVlD2I0J14pajatwe0D/xNe9dDYy+nf44VIWD1MGym7u0OJ/o1uY8/WfQA0OqU+r//27OE/aBwHgUNXIUkpZQohbgc+x5YBeksp9acQYjSwTCk1G3gTmCqE2IAdlbjykBw8joOGjLaTlj2zFqKt6S6FkhLQEEKhXBJMJzHO5eR0KOl4uyJsM3ONACIRND9opig1J2t5wPAT0TIGpAtQAi3oqFCEPo44UKC6znNDe9O4YTVqVE3hnJ5RSgACcqWFpgkefewTm6rs2MfXJn5LUbHJlGk/AtDxjKbUaFwz7BADfDFvJSPu615q5u61bx5kWLen2bxmB63ObBLjEAPs2pNHSQi3Qb+R3albO6KwdEbHJiz+aUMkudzhPuflF5f5mxwqbP5zKzefMiK8/OCHwznnimOTCnHkI26Ly8ORlmh3WHBi1TvC3yNOWuSGcCExcMo0I0jWfYTYZFLayXQeXZJoBBHKXh+UGiY6QhPoQtks43AytYauCVb1epTqelW7SIe9xU7M04CgsB3jYtCsCF/sgc++5K1lK7j05bfJKMhHahF3u25aSpnXp4CZi37F70gY+QImD771WankMUMv++e+vPfpzJtzFx/NGEatWmmltp8aKsLhvBS4XRo9Lmod06Z69VSmfzaClqc2IDpb78rrD+9U0LrlG8MOMcDm37dRUBBr/IPBIE/0H8+EoW8e1nOJo2KE86Mq+FSuLzVPKXWiUuoEpdQTzrqHHCOMUsqnlOqjlGqilGqvlNq4/x7jONw4o3qE71/Wz6wZEqHZBkQYCvSQNqUCtwUeIEGh3BIZMjQOBU25naCDpsLmXQEXndqEWXddg+UBKzRhJ0B6gCrCtvTCobNF7TfkpY/5fuUmzrxxPL4UjaAnYk/btbbpIhs3xpacV8AkxyEG+GnxX2zfFcsv3h+enz+STzaN57F3by+1rX+fDqXWtW5ZjzolbPYTT/XjwUd740p2I90Rybh77r640udxMLinS2yS3ZhrJ5Rq88uC37jv4if4/uPFh/Vc4qgYcVtcNo6oSLEQ4j3gPOxsxwzgYaXU/9uTOS6xE+fU/ZQ9xd+xct84NCwkoYQ3gVTgFSY6kgKVgEuTJBKgwEqgCK9zbvYN4jVM8oJ2OMGSNp9YAIaw8FkGQakDGve1uByAHYWFxGgDmYCpIxDoShDlL4OT3/bFmr8w/EQMtAZ1qiTz4aBIVSIhnGQRBz5lO9vO8wTTtHh0cDeGPz0LqRRpKQkM6nd2zLjkFPjYsHMPpx5fu1yhdoAJj1/JD0s3sPCHtZzZ4QTanNSgzKp4qamJPPvqAHKzipj78TLO79yCOvUrx/E9WJhllJKORjAY5GJPZCZn3utfMt/33mE9pzjKhlIgK6F7Gcc/j8NliyeddT1f7ljF9E2/8O3uvxwbppxjgm4AWJgBDaE0lNtCmk4lOzPqJV8HXMqZZcNWqtAUViIIH2hOEp7LrfF8nx5c//qHNjdZtyPUWsDmGQcB0gQiX6FZpRhtjJn8lRNBFlgJoFuKKy9uR+uTbaf47ru6MWJkJCcimCSwPDquXCsccUqrmkSHs5ry8/frAbi83xmlosTrtmeS5HVTt1rpoEQ0vvxkOJPe/RHLsjir44m0aFaHspStzj2/Beee34IVKzbz1+a9XNF7f3lShwaWGatdFJ14CDB19Ie8/Yhd6GnpZ7/S/bbODHu5pJBBHH8H4ra4fBxRTrFS6tDUoiwDye6GJLuvZUPODCy1Bb/jEPuUC4TuFEKS4TRon0OZUGEhTBsh5nBQavhNg5BypcCFz7I5UQm6m6dWfM9/f/gcoYWSRDQ7ohGMhCMsoWhTsw7r92VRnB8M89uEo7MpIgdkZ04BfV6axkdDr+GH9VuwXBDxqO19pGFPESoXJKV7Of3kBnw/ZRi+gEmiN5av9b9OrnEAACAASURBVMxH3/LO15HiHAvH3kzV5PJ5YJ1Ob0Kn05tUaqxT0xO5euA5lWobjXeenMnv365i1JQhpNdKr9Q+LTo2IykticKcQgCq10snOTkhvH3Oy5/HtDcDJsFgsMwCJnEcfhzKKkpxHD4cTlt8YZ0WdDiuMWd8OhYsGWNnwzUxdOkk35Wdtu4YbFTAdnSd2km2apBb2HYQCCrJKU8+T8CSoDmBZ8c5FlE+XOOmNcjPLCI334dpRTZIFZlOVULgS9OZtPhXTjujEY3qVOPDxX+SX8fA8CubpqAEmlRIA/wpOnqSzq7iQh57uh8BnwkauN2xj90O975IkfNy36RmNT4aVX7hDJfLxS0Dzq30WLdp04g2bRpVuj1AQUEBY6+aQP3mdbl1XOWLeDw8cwTDz34ovDzo2Vgq3rtPfBSz/OnEBXGn+B9E3BaXjSPKKT7csKwASRooLCw0m5qmQpUx7GxMTUnyTQ8BZZROjANy/B4C0kW2z0tQ6o4xh2RDw6vbjnR2ocLnLyBs5DWbCmeLA4a0LcEjdFZm2IUS6qQmsyu3EBUETOfQoVlAx/nduCebdg9NwAo6GsmROiSgwHALQukm367exP3TPmfMNd1KOcRAjEMMMPilT3hv1NUHN7CHAFfVuyVc9alfnVt544//0bBF5TLaP86azB8/rMZwu2hewnFv2KJ+qfbDOt7P+B+fwO2OO8Z/N47M1Io4/m6s2LeJmomCfT5b0lKGp2rtIINSGgibzhaumBE2yCJs85RmoUk9MqsmoFpSAkXFFlJKgsUWgRDNwmWXhdaUEzE2QDNt5/ivzH1YSiGSIc10U1gYIKiB8ILLR9gzlk410dtf+BhpgBZQCF2zVS2UAglaQCBPSCRg2nS24RPn8OnogdSpVjqp94tf14UdYoANu/eVavN3oqCggN4pNwCw+NPlzHnlc+YWvFupfVt2Ook5RVNZMnc5bS9sVSrZzpPgoSgYkfNUEmY8O4cr7uxx6C4gjkojbovLxjEVP/9x+yUUmusQmonXkXmwi3TYRrPI0imQCQhNxy1MTKERlJojwSbYWliVPDMRn2U47OBIFFkXXl5sN4BTU5vg90e9ayhQpmbTJvyxpLVAQSQisaOwgB8H3YQmsbOv9SiOW5R/bkYqS4e6QQmw3NAoKtkCYPnG7ZUeG62SxWXWLtnAY/2e5bPJCytufAAoWQb1gR4HVgWyZaeTSjnEAKd1bk3txsfFrFu/fBPjrn/xwE8yjv83DmEVpTiOUhQEihmxYioFlh+XbqEJhSYUQigE0lGBF3a+ho7jxUaHbCP5G8ItUMKJHji3zY1ntGP0Rf9BL+M+Uk6xDnT7I902xcJyPAQFFHpMPFXdqESQCQJ/VfCnQiAVLIdXXEZqCkpAMFGg13ZTZJpE45f1ZZdOL0Mls9J4/6lPGHPtBHZuzqy4cSXxeJ/xMcv+otJFQ/YHr9fLOVecWab6xGsrnym97q63ydy6p9T6OA4/4ra4bBxTTrHPikjneTWTAumhSHlQDr9YqkjCmybABRSabootF4XBEIfWnqMrWQAt1ZVMm/RGpIhUpBJYlsAKgPTrthVWWlRc3plmKzH8n69dH95MSE4o5EM7WdEisnvYMEvDpkysz4l1LDu3ijiJpil5bOoXXDd2Gp8vXcNNXSIlQQXw0uDLwsuL5q7gimZ30e/kkaxatim8fsnnv3J7h3v5bvpP/G/gy4wb+FLZA30IUK1O1YobVRJvb3iJ41vFRp0z1u08ZP3HUTkoKmeEj0VDfCxhVV7kZV3TwKVbCKEwNIXLUBh6WDcBAN2QYWoEGqBEiGxRunMBDVPT6N2yBUEspKawdGWbYMcZVm4n4OC0D5So4xm0JAFlhrdHeBkC5bLNue7YcmnYfSlshzmYCtkeE09y5FkigI4nNQwvr9meyfWvfMjgN2dxWuN6pCREyj+3qFsj5lweGjqVnh1Gc+f1E7GsCF9ucPt7efO+aXw97XuuO2Eouw+RY9mweclCZIcOtRrUYIGcXmp9xvq4Lf67EbfF5eOYcoqTjIiTGOKxRX50m+rgERCUOtmBFLb60kAJ8gIJBJSLUIxAKXDrphPRUGhoPHJKP3YV5TF90++AsCMAItJ32Ml19vHoGoYI94jSFN9v31oOgc7ed+Wjw2jgTMEZHo17rzjPzqB27K8lFd3bn8SpjWoxpNuZ3NXrPMCWY+v78BRmLfqDPzbt4t7X5/H+Wz9SPRNmP3QDK14czorPfqVr6kC6VBnAEwNepSC3iLysQkZcar/db/5zK/d3eyLmlL5699DUqP95bmwpaU0XjF/0eDmtS++76qe1FbbrN7JXzHLfkSVLs8fxd0BV8hPHvxenVI19QbUrgUaqiSrAYyg0JRAKDMsdtqUCmzamwrYU0CNloJulV6PLCU0ZNe8zgkg7suGUkw6ZVgVhVR8FXHDyCYDNUgskAlV10lMTy7XFV17Yiudv7+2UjxY0blSd49scRyBNhM8zIc3DGS0a0P7E+rwzsj/VnaIUv23cTp/n3uWXjdv5bs0mzr3/VQIZPno2a8Z3owfx/ohruKXbM3RtOpKuJ9zF4oWr8RcHWfXrNkYOtKuFPnX9BNYv22DzD5wIdyiB7f+Ljb9vjVk+rUvrclrGoiCngM8mLyRnb06FbRu1jFDaEpK9tDq3xYGdZByHBHFbXDaOKU5xqrcbe/M3oRQUSzcBZRCUGsXKY5MhFFT3nsWWrHXkO1JsQWk4lV8cfrCCgNQoCHgAwdSOw2iQWINRv3zMt9ttlZGQLyx0hR1wCE33CdAVWIIUr4efBt7KWZNeJ7PI5ll9seUv0pI9FBQEHcvtnLiAD2/sh2FozB85MHw9voDJU59+hyll+O795NfVAEy42Xb6cguK6T7kNQKmhQswE2zZIktTmNv2MeKmiUyfPZKnbpxoV4jSNAgGQXekfBQEAgGGnH5vqfFMqJJQal0Iz978KvPf/AoATdeYW/ROucltD146Nmb5sTn3lNtvNLp5r8IM2BGdWifUZOr68ikRF/Q/mxr10vlx9jI69WrPKX9TBbc4oqA4JiMPccQiQXdTRfOSa/kQgN9JqDOtUJDCfhzXSkxjR34+fmnZUVoV0SbGaSUUoAnOrNeAFy/sTkZ+Hl2nTWHDdoebG+pOYNs3BAiF5RGoAKBBt7bNGXhWO/pMtVUkfMpisyogUbM156OdY4+hMaqPrfW+7MVIKeR3flzBqh3fhM9rl6+IneZW6qVWoUXDmgC8/eUynpu1yI5hCNsWS7dCKwry9ezl9O/QgtnfrGHbX3scTXsNEZTYHBL4a90uCnIK+HLqd1GjaVNLmu0nCfqSpKsJFNs0iNO7nsqT8+4vs920J2by69d/hJeFLhg7/4Fy+w3huxk/8ljf58LLo965gwv7n11u+9d+fYaPxn9KfnYh/Ub13K/yURyHCXFbXC6Oqbtxfd6r4JRj9mompqlhKhc6kqDDVfgtZwVB5QLcKCUwoygVUiqKLRcBaQ+bQvDh1h/ZmOPj+8y/nHKftiKFUzkUJaQd1gh5yjqgoNgyMQyDvcVFMUY3T/Oz4YGIAHpJjPhoHnP/tCOjyS6DuSMGMO7Tb/nqj79i2g2cOJOZ/72WafOWETSt8CF0v8J0KZK/WYPwBclVimHnPAwQK+0jJUoIdF3D7XYTLEP67IUfnyi1LoSQQwwgLckDl4zlqS8eLLd9NH6e8wvtu7aNWTfpwfd5f+wsNF3jrrcGs/LbP8MOMcCuv3ZX2G+rc06m1TknV+oc4jhMOBZDD3HE4MnfPgo7xApwG5LiQOhRZHuwCthTXIAlHa80ZE9xHFvltBOAUvy4w45wXjZ9GqaSCC0ky+bMxjlUNCUdlQhh0yiEhIzcPLq2ODE2Miygf9fTGHlh+So6J/1vPEFpRy5uadeOR3tfyKvfLmZbYX549i4jNz/cfuL8xaGubQfdBO9uH2lL96AEDO8xnlqNj7O3CWE7xkoRKvzVuv3xZKzfRUk0Pa0xlw4qu1LdxFFTww4x2FJo5WHx/Njk63Bp7Sj4inzc0uoudm3OpHq9ary+8n8xDjHA+Jtf3a9TrGlaPLnuSEDcFpeJY8ophihGA3a5ZlPYeRwGChOBiWG/mJtghUs4A9gOsRnSJdYlAVPxccYy/L5EQKFpEuEysUwdJTW7aIdjtIUu7SixAiUEBZpF+w8nUMXtITfgtykUIvb8Qnhj8TJe+WEJLk0jO88pTCGgIBBkyuLlvHDtpZw8yjFMAYuav/jItQrpNXcstWsmEiq6EYqsJG/IRfiCCEd6aM2SDQivJ6IrqRSq2EdCaiKvL7ZLPp/e7VSWzFsRPqc7X7+V+ifWqfS452cXALB3+z4mP/g+wYDF9Y/2pc4JtTDcdlnVEPreHUtt2L0lk2lPzARsB/up6yaEHxRxHF2QMh6dONbxdeaq8HdBmK4bhpTK4TOqSKTXMV4itD5kl0NJc5bitHdetn1lDZTHnqVTJmhWxDGWhkIm2BxlTHvfx5d/Q8AdecFWQiENxcaiWCWIXJ+PWz/5hFWZmUhTEbBkePZw4pJlbBh1J9sL83n5e9v5TdxpkbxdcU7PcbRpVBNREACPCl+s5oeUP3MRMkLt0LAdYuU42/h8UATn9OnA/c/Z6kBCE2FbremCl5eWn5ScvbN8OsMPHy/h88kLaXZ6E64c1YurH7ic+y8eE96eXDWp1D5PXfciOzfaAYg9W/fyeN/S1UODwf1rx8dxZCBui8vGMcUpVhCu0mIpgV/FvhNIJTi9ajNqeevgJoh07JfmfEylg4hoaeqaMy+nBQCJy1C4XRYJCQGOS1X0a9Lalk3TFOjK3k+AcNnGPtNXyPktGmBowq7vYdgVlxq9avN49xUU8fbi5Yz/7kfy/H72FUUc4hA++GIFa7dm0qNNcwBqLi3GtbcAY3cORbvz+GvJFrybssGSeN0Gbzx0Fc3r14ip/KHpGrMzX6V63apgmajiIho1rUHfIRdydYNb6az1IS+rgFvGXcvJnZrx2Ox76Hbjhfsd6yZtj49ZHjP/PgBGnPcwC6Z+x8L3vmdYpwewTItZOZNp0vZ4ajWqwTPfPEKtRrFqEXszsmJ/R6lKVeuL48iH/fcXT+441tEizeaUhnzdoFn6MaSAfie0JtXrISI1QVReBo43TXhbiFeMpsANMlEhUyQzB16FliCQBkivo2KhYfONnQTmpxd/z4jzO6E0STBVYiUrPsv4i+4fvA3Ayh27uGvefH7duZPCYJBi04yYYefL5c9MZdj5Z+LSNPCbpGwy8WT5cWf5+XXdDry/ZWPk2873SfVrsuCxgQhdI/p2b9KiLsPHXoHLpaNy8xF5+dwy8mJWf/IDnbU+dNb7cPfkIZzRvS0derTjk/y39zvWd755W8xy9bp2AvOqn9Yy5prn+Wn2Mt4b8xFvj55O+65tGfXOHdSoX41W57Zg+u43SvW3JyP2RWHvjqxSbc689PAXConj/4e4LS4fx0ykePWesXZk2JmKy7fcKCI1lIPKrkR3Q2N7iv+qn28BIdCRhGoTCaS9D7Y9NjRw6X4M4ULhjijIA0XSz5Ptu/LZ1rXk4QufRyiZJISVWbs5v8nxfL45lv6wdHMG102ajhS2bFBYkcIEDOc4lr38wMR5TH98AI9dfiHdWz+IKA7Yz49CH9JjkLApm5Tt+cze+gIAE9+9g34NbiN7dx4oRc2G6bjdbt5dHfvW31nrE/6+5uf1+It8vPjzWNxl6B6XxCvLnmbpZ8tZ+e1qrhvdF5fLhRk02blxd/j6C3MLyduXT9Waabyy7Oly+zqp44mkHZdCTmYeAC06nkjfuy/lkcsiEj93vHRThecUxz+MkH5gHMc0thTsDM/cKgWW1Epppp5RvT6Pnd4Nj3Dx5pqldulm6YRlw7dQlLOcYIESnJCSzl/5OUQTj1/+bTHPduvGHfPmhZ1gez8VtaC4tVN7xvwWzdeFP/ZlMnjGJ3y5biOWS4VpEdGHBxAmrMvcyzd//MUf9w9j8gff8+7XC+1DAO7cIAQV1Vbm0+uajtzmlFx+64Nh3NzpETAMZFER53Y9iU6Xns5Fl50e7vvN+95l9+Y94WM+fd2L3PXmYLrccH6FY+1yuZjnn8b7Y2bR8OT6nHN5RwA2rNgcnm3zFwX4Y5Gdi3Jh/7P3S30Y8NiV3BtVznnAY1fxyvDJ7HZk4YQmeHjGyArPK45/GHFbXC6OCad4zb5n2FrwNh4NXBIsIchV1QCJX7nCiXRNkiOGqI63FhnFu3HpCkNZgKKaxyLf9GJaGglGAL9lIAS43BKpoCgYSSRL0t3ous5v/e5k+Z4Mrljwdtjwhwt5AIbSOK9+41JO8RPzF6IAoxCMvWAZCn+6AqWhFYNwhOJdPijIzeaSpndRJdULvmDMM0P47KmspBRvTP9ZUW/829fv4qdPl9Hxkv2/4W9ZtZ35b35NzyFdKzXup3dty+lR3GDDZXDKOS34/btVTsRekZDq3U8PNjRN472M1/h80kKSU5M4t++ZACyQ01m7bAPHt2qA212xox7HP4846+XYRqfP78dChn3LgGmEE3pD94YQgvHt+wFw68kdeHPNUnuWzbCVfzRDASbS57KTmXUTzbD72Cz3EU7ccJLyGqdWpXuz5nRv1pzLZr7L8t07os4ockOu3Vt2XsKX6zaCBE82YIGZAFYyEHCC1Qp0v62UMWHsPJ7YVUijuqmxnM0oX77pSRHa2WvDJyH3RmzxI72eKSVbFnaIo/D8oImc07cjCUkV20+Xy8W1D/WNWdfmgpYxy95ED5VBu86teWv1eBZ/upx2XU6l0cn16dTzdLKy8snflV3pgktx/POI2+KycUzQJzLyI7XpNQ0Moagq8tE1RaLmI0krwiuKaJN+Lu9tGcPDv/eiqr6eRt764JTpABAapLgDpCf48BgSQ1cOtULhMgLownaedSF4o+MNzN2yiqYfjKHPV2+TqnlRpkAFha0HJIFiwZrMbK46uTWpbg9I0PMhIVMDS6D5wZOjMPzgKYC0DYKknSZ11llU+yNAQqbEyPWjFm3DClrk7C1EBIJ2coZzvcIXQPr97F21iQm3l54OC+GXBb+VWtekbaOYZaUUgeIAxQXFfPnOtweljVmnSc3wH6MZsLiu0e30qno9fWvfxOY/tpa7n2EYXHJz57BDHEKzdk3iDvHRhH+pDpAQIkkIoVfc8tiG5UjqaJr98XpMBBJNUxiGhVsPkuQGjyHoNO8xOn/1FJ0b1MLQ7Fk9IRQIhWYIjGQTPcHEcIPQFEJXoFngDeUnKFpWP467253N5XPepeGbT7Myb6dNs4iQeMP3XJ9ZH/BNf2fGyQS9UHCyWQMBuApA9wmMoMCbC1U2QmqhoNoWQdJ2MIogda2f7B0FSEuycWs2kqjbWcrww/bZh2eRtdtOwNufzQvhtmevLyUPp5RCmhab1+7ku7m/xmgYVwb1m9XFMiP6zEvmr2DQ+Y/R+4Th3H/lhAr3veLOHjQ6OSKtlp5eJe4QH22I2+IycUw4xYl6Y0K/bsghSxIBkjQ/iZpJkmaRopt8sXMqa/J+BhRBinDpS3nopDvRRDjTw+lRhUuShvjFbk2S6LGo4g1wc9MOrM/JZthPHzuKFJDt8zsp0KGKHE6GiHNCvw0cSpUNOok7dYwcwYaNezCiiwkJgdIVaRuCsC+Iq0CStjlA+i97w70Jy0kgKSxCFRdDVhbW7kxkrk07mP3y52xZZRthTY+1sgOfvKrUuL2ybByDnr0eT6Ibw61T+/ianHxWcy5NuY6nrnuRaxoN5qPn55ba7/7uT3JV/VuZOb70tj++j9UUzs7MpTC3iOzdudza5q7w+omjpnJp6rUMahefivv34N8jGC+E0IQQ/YUQnwohMoE1wC4hxJ9CiHFCiKb/9DkemYh+0ipAkugxSXQHSHBZeNwKhJ+zv3iSAhlAAYvzNtKgqsWzZ3bHcFtoetRUm9NPOFlPgNAkItFES7SYcEEPbvh8Jssy7YIhQUuC7iSJOCoUoWy/gmCARmlpPNr6PBL26LjzNDbuycIdEAgz2i8VCAuMDAXFCncBNNNScBfbCXOWoWF6dcwUl/0KICXu0AkKgWUp+ncZB8Cg8QNiRie9TlqpEUuvVZVZWZNo16U1miFweQz6jerFiw/OZFCXpxlz+xR6NhtJcXFs9bmN63YyoOsz3NzzOXKyCkr1awUjjrTweNi0eie+ogDLv13D6IGv2eMVDHLjZRPofc4TfDj5+/3/tHEcRYjb4vJwTDjFXvUTBia28ZR4hB+3CAKR8qIA+4J7gUg2tC5g8b5pdKn5H9uGOu/+Ihw9jhjm0Le6nlr8ubuI4d/PDakG2XQJU0Chjsgz7HLPCghCeQrxQim0Als7OZQdqPmdo0iFHrDQ/BYixQtSgmk5WdmA2w2BIFZBUal+P5v0DQBzi96l5VnNadCiHlM3v0xiYmKptgCX/bc7H+2bzOS1E3hr1XheHPpmzPY37pkWs3xN48EsmbeCvduzePXOKXzy0vyY7d0G/qfM4wBIRwJoyiPvM33cbIrzfWxYvone1QeUu08cRxn+PdGJhcAJwL1ALaVUfaVUDeBs4GdgrBDimn/yBI80zNm+iCTDR+hH1oVFoisYXg7ZYl13QhBRqhR7rWJ6Nz4Fj6aj6SGb7ZSGFrE3jEJhCI3rm7Sj28wpfJOxKfbesoAAtv21/XKQ0L52PQBe/nZJTH+m6cy8Rd2but/+v6WB5YbN+3KxDLB0gfRqKJeGcmuYKS6QYPliyz6HcFavMxg9ZxR1mtTiP/3P5oOM18tsl5yazJj5D/Dhjjd4d8urDBh9Jd/MjqgBWaZk6jPzwss+n5/Bl7/Iru3ZbNu4l6vOG1O6zyh1CeF2x0hyrlpia+73PnsMGVv2UlQY4M0JC1gwZ3mpfuI4ShG3xWXimOAUA1TV/YDfLtyhXCSIIIaK/OqWEAQtu2YFEK6stGjfZpKNYoTQ0JDownLUKyINFYLsokSk1FiyuwjkOkCgLGxnuMgZZscA63k6ShMoIRjaqj3lQTft/rUg6BK0gDP1aMowR83yetH0YrBkbMWmwkJiHW77OvuM6I5pmgw+bRTbN+yifdc21GoQW1q0JNweFzUb2m28JThsuit2lqIk/23mc5/Sc0i38HLfu3sipeSzSQtpetoJfPNeJPpguO1xmv3SFzF9FGQV7vf84jhKoDgqIg+VxIVKqRjtKSHEiUqpdcBMYKYQouxqNcco3t/6JYYBqYbtUSoFptTQNenoCTu22NTD20N+mpTQ/KPRDGp+Ni+tWYRwHGOlsKUvndk7JQVYOoEgvPX7ckK8YhS2LVYglLNOgggIex8UEy6ytXOb1qjGL1sd3rHjFCg3WAEwfDZDA83OU1K2LD0A/npe3Dv8kQsWAmUIimt5kQn2NXl3FePOC6I7D5olyzfx6NQfoG0ThlRCuze1ekq526qkRQIbX8+NpcMpBaZpxhTK+GDnRO7vNoasXTlUa1KX35dsCm874yKbcxwMxtIy3nvrezr3iNWQj+MoRNwWl4tjIlIMsaRyhSIP24CEoxEKAqFYsNM2K5BAQLnZF8jGkhp5AQ9+U2NHQRUyCtLYnp3M1uw0MrJTCZg6xX7d5gs7msBKaqiikNW0DbHut6fetKCGHhC8+dMv7HDoDd3bNLONtqlwFThECyFwJeo8NqgLLRrU5Ljj02OSNgAGPXUlHq/Luc4QYdfhi4WeKprGiLcGkV4rneua3M7mP7YR9AX54eMljBv4UqXHcfQnd+PyOIZVwCMz74rZXlKZouXZpSvHXTmqN5PXvMD97w5j7OcPUKtRDRq3ash7214F4KQOsbMdmnHM3Kb/fihRuc8RjpJG2MHNQohBFbQ5ZtEiJSLTGAo6hCQvo6PCQRWxwSEJzaClo1C8tGYRZsCefbMsMP06ZkDD9Aksv44M6s79E7G5dkc4djOyTjj/NAEagv/OtyOt79zcD5cuYhORNFAeeH9kf/pfdCrpJ1fBUyUqICDsqPFD9/UMX4hCIXVsh9i5QF+tBNLSE5n1032Ypsldj86gqDhAUXGAux6dgWmWHVEuCzeM7B7+XvW4Klw1NFLAo23H0hXuSlaOc7vdjPvqYd788zme/uQuLrqqA9XrpHHxtWcx/Nlryzxm+7PirKB/DeK2uEwcE5HiOqkPsz3nUUwFAWkg0bBIQQjbAIXKPoOOX9qGLt90k2dG3rx9JuQFvewpTnYkhARSGfYbFwJLaVhmFOssWnotREeONswQTojLzC+kVpVkvli+Hs0Co8Cx2w51wsqzePR/8xGOn2skG7gK7HP3eF106XEqZ5/bnJs6PUpxgQ/MEkkXQtDjtovoOsCmLuzdFqs1ueTT5QSDQUac9whZO7K5771htOjQrMyxTE5NZl7xe+WO9eR1zzOw+X/xFflp0vZ4Rk4aEt52b7fH+eWLlbgTXDy94CFadGzGaZ1bM3XjyzF9PD7nXq5rMoSdGzMxXDqT1u8/8SOOowhHx3TcwWIfcJsQohnwG/CrUmpFBfscM7j/5AGs/elRdvmzbRaDFI5cuoiJCivHqQ05xAEzWkcNUAIrGHFIBSIqvBOqAKdHJNdEKIoQ3UfoP8LROIatuXahi/d/XUlRgrLVfZxJKqnZinCXTpqG7phXUU2RuAeE87i95MyTuOCck1BK8dALnyJdGpZLYASijiwE739tl7FfvS5aBcPGxs172VtYxNhJX1H/uDReuq9PqTYh9B18AX0HX1Dmtlp10+l74zlMf+s7EILhj/QOb9uyM4sbHplGUXGAExsdx+RH+qNpWpmO8Evv3srQaycipaJp89rcNqJbqTZxHKWI2+IycUw4xbVSb6RW6o3kBrYzfXM/Qh5qUBq4NUlA6uwIpIUNs1IR/jBAnt9Dnum1Z9yknSgXJl4IESpahyVjKRVIwK3Aj/PWBaFSo6EohULRovZx7MjOI6gksX9UNwAAIABJREFU6BBMBne+fQBNgXIrRFQ1aMurIwIWul8S8AfJ2JpFkxNrUb1GFbblOFbc5QKnspBuaNw8LmLw0utUZd/27PByu66ncmnytZjOVNmwMx/gzdXjadCs7gGPdY161ZlT8E6p9V9MWciyz+0pPX9RgPsufpKPs6eU28/bGyofvY7jKMK/2BArpcYKIb4G1gGnYnPa4k5xFN7u+DAAY/74iE+2L8F2fqVd1hhF0NTsqqHRQYVQkrQEEOguhZQWygolLUO0wyuEQhkWmCFpCQEuZctYhgKxhoKgRkinRwloW8+WSnv7txVYCU4EIggCDeVMgGlBwAr52ILCGsqu3aTD8qJMpFRceG4L7pn6mb2DpWz+soMOpzYKf2/aOLZIEUCu38fwZz4GYPe+fM676QW+eeOOSo5uLAb+twsD/9ul1Pph4z6i0EnKW7s5kzdm/cwtl59Zqh1Ak+Z1mL/0kYM6fhxHOOK2uEwcU/PSm/IXEm08dwSrst5Xiy2BGpiOcqZUsNefyLbidAqCHvYVe8kLep3pPoWuOdkZjsW2a9M7HcpINrOQCqG0sOSPMEFTAulRjhA9dilpEzJz8+j7v3cjwhS6QIalNsuevtD8NodYScXIIXZVoyem28ZTSonQBJohSKjiISHJzbcfRLi772x6mXrN6uDyGJzRvS2jpgwNO8QhvDp8cqljrlu2gZ/m/oKUESmf7N055OzJrXDsd5XgGvsKfXzy0mfs+GtXhfvGASsXraaLqx+dtT6M7vu/f/p0Dg6Kf82UXXlQSi1RSuUopb5RSr3wT5/PkYqFu/8gZIuV0igKuCj0ewhYIRqY3c6SDr0irDCh0DSFrodskHIiwtHTcgrdDXqiRE+QYCi7NLJbQaKEJAmJCpVsoTSJNCTKK/ksYy17CwtYnbc3fJ5WGki3Ctv16FszFBSRHps7vC5zH+8stp+7F3ewaWPSJSiqBlYdDdXIw1qZSyBgO6SGYTDu4cvwegy8Hvv7C+8tihmnYn9pOkXANPnqt/Vs2BmZ8TMtSca+XPzBiukX+UX+mOXF67cy55fVBA9Q1u1YxaCXP6L1Hc/R9r/jWbOtbG3rIx5xW1wujimnOMVoRKHlJt/y4Lc0DCIOrQBMpbGlqBpZwVBWrsAv3Ug0lOOxunWFJiy0cLlR+6axJIRKQAuBU/lI4dZ0qnuSIpm9AjvqIFV48Hu+/i4Fvlg5nZgK1EJgekMzfgq9MKrEKFDsGLkaddOZv+dVXIEilM+HDFoU5xVTkFPE/wa+wnczfgRsYzxp9fPMK36Px2ffW+ZYtevSOmb56QEvMqT9vTx06ViurHsLUkomPfgeVzcaRP8Gt/H+U7P2O/a9hnbD5Ylw3RUw8e63ua3N3ezceJQalr8RI859CGnZjsCiGT/z+ZSF//AZHRxCU+IVfY5WCCFeEkJMdr5fVEHzYxYu4UIqOwgR/XOHfnupNNumImL4xqHvmgYuj4nQFJohQZO2FJvu6BUTkWjTDAlK0TL9uNhkDB1UkgKP/d2HyXPLfnAORLitilK3ULoKT/qFEN3ln9vtym6jb+rGxHv7EEwG6dUoElAQDLJtXy7t7onMgp3R9gS++HA4X3w4nDPankDb5vX2O24FxX7OuecV7nxzLpePeZuX5/1IbqGPnmMmc9lTb9P5kdfZsid7v33c1KtD5Ho0WJmVyWMzvuSOt2bvd784YNKXS/lxzRYALKnoN25aBXscuYjb4rJxTDnFn+wYjak0LKXhU27Or9YTt+YGBX5LZ1dxEgLwaBKXKKmF6fDcEBjCLtgREmazpMAMGDHGUQB3tD6TP68ZRt8WLcN8YojtVgAFgSBVo1UdFBDSxXTapqQk0OKE4zB8EZUJ4Q+iFfgh38++PXnh3f2FsZGAEF4ZXj5dYfCEgeHvjVs35LJh3WO2L5j6bfh79u5cvp62iA+e/oSg3yToN5n84AeY+4lSpKRXYcaeN/nva7dwQuuGSFMS8AWxLMkPc5bSM/U6Omt96FP7xgNKNjlW8eXU7ypudCRCVfJz9CIAbHS+l68/eAzj04zl7AlE7JUQ0L9Rx5BcsB0NFhaGrjB0GZZcK+kYCwGGW6IbCsOl0F0K3ZAIjRiZthSXlzf+czkzLr4GreTMW1ROHsCq3MyYzQqFNBShf1KHDifUR7gIl3yWYMuxuWBDXiR6+9O6bTEzfZWJuQ2/5nzqVK8SXn5syMUx29/9dgXFgYh9fGvBUj5Z+ie7cwrwBU3yiv289sXi/R7jqq6nMWX01Qy58mysGjo+y6I4YPLD2s1M+vEXmo9+jmajn+PJz76pxBkfW5j/y5p/+hQOHeK2uEwcU06xqQQWupNop7M8Zz5BmUKe6SHbdGPhikQihEJD4dVCSYuKoCXwmQZBpRE0NQxnCk9aIhyVCN1JhtBZlLGZtdl7ufvMs6mRkERIks2QGlqUiUxP8PLVwzfTqEZVu5JSMQgNzHC0WPDoHZewdfVuCFpoRSbCbyL8FkIqlCm5uduz4f5Sa5Qt29OiY/mZw72HdGOBnM4COZ3XVjxTarumx94q6bXTYx4wmqEhtP2b/cTkBC65uTNtO7fGk2CT9IQQTBs9g6L8YgBydudxe/uyo9fHNEoMbf/7L/9nzuP/i3/5lB2QCqQ6EkDxEl9lYPKGhTG+qACKrQI8holbN2OcXiFA12SJiJVCExJDl+iaFa5yhyPLI7QItUIIRYI7yHe71yAQzLvk+tiTkVHfBQxp3ZFJPXqja6AMCV4FVRRWgkR5oFpqAl1an4hWRSfoVgRTFNLrUOI0+H1nJu8stSkUl55eWnmnMpj13M0snnoni6feyUUdmsdsS0+O1ZN3uww8LiNsezUhSPRUrD7VvFFNrrqoLQleN8LZr05aCmO//C7sB01ZsoJdOfkHdQ3/Vtx0UayEagWPvCMbcVtcJo4pp1iVCAtkm34KrTx0oaiiy1Lt3ei82u5expwyAAMXptTD++u6chLslF2yVJcIxzAqIOCD5bt30v3jqbSY/DwTunfnuwE38uV1A1h313DaN6yLLgQN0lL56a5BGIZBRkY2ut85ggTdggSPwbg7LqVFo1pIqdCLLYR0ngEOBOCLqmY0bdsrtDyrOVXSk8PrUqon8+CHsfJpB4IRbwwOO8ZnX34GbS84heGv34bu0kBAzYY1YrjG+8MNj19Jz9u7cur5Lbnz9VspdBziECrLMzaDJhtXbiF3b17FjY9yzMiaTNWaaXiTPAyeMJA257f8p0/poBDyXyr6HMXYCPwFvAQcvXOrhxH1EqsCxNAi5u38NSooZZVKpRja/Fy+7HIHXeuc5BT5CAUv7ACGrklcLhNDt9B1m1KhGRaaYZIt/XywdQWtZz/Jc6u/4o9+w/io2zWsuXoEP195G1VcbgwEQ0/pwIUNm7DLn0/QY6H0KN/AqzipTg2+veFG8n0+AtIEN6Gc7ZjCF4s22tPr9atXZcLAntRJr4I7Kqgw6KIOHCz6nNWKVo1qAeDSNZ69sQe92p/MaY3rYHnAXx2MqpXLn3cZOlOG9OXckxtzwSlNeOXW3qXaLN26rVJ97SsuYvXePf96XvJFbZox5JKOeF0Gx6Uk8cOY2//pUzpoxG1x2RDqKCaNtGvXTi1btqzS7Z9e1Y0wD1gpsoJJFEo7ic5nGeSZCeG2SkFOwI3pkHs1aZATdMVsL/a7sCxHl1hha2eaOtIvwIqSEVIgLMHrnXsyeOZcFODSNFYOG4zLFemzzZDnbNqEVBj+SHCwfs00ZowbyAvPf87cd52pMSnRimxH2M6qtqComMmLH6Zmver7HYeHL3uKJfN+pXrddCb+9gwJyQn7bV8egsEgF3v6R1YIWGBNP+B+7u/+JEvmRRJDew3txpDnB+5nDygu9DG0w31kbtlDwB+gU68zuH50v4NSzIjjwCCE+EUp1e5A9/M0rK9q3zesUm233Hb3QR3jn4YQ4gfgPWCBUmptRe3/LTgQW7xk7waGLnszRmFCOhEphV2owy6OFEU9iHKSU7QksoP2i3RI7zgC2xabVij4oZx9Ix3UTUzllJR6zNu+GoDzazVh4tlXhrdf8vFk/tiX6USRI7kgAC+cdwln1m5I18lTyPH77E1BO5E6BMsDddOSWXTTLfsdhx25ufR6Zxr5AT9XtWrNQxecv9/2+8O4bxfx2uLI+J/VsAGT+x34bFLz/2PvvOOkKNI3/q3q7pnZHMhIFkVBFMyICRX1zOnUw4QBPcV8Kp7h55n1zDmgB+qZMZw5R1QUEAEFJEmOy+bdSd1Vvz+qJ+0uywILEvbxMzLdXV1V3TvzzttvPe/z3vJAxv2cfN0lhOzGneyxC+dz3odvIYUgLyvAkN47c9muA9d67BasPVps8eqxrrZ4rSPFQoibhRB3CCFOFEJ0Xdvz/0yc3OVOQPpV7WxqVBDQxLVFVNtIoZI0mqiy8HRKC9MTLra/LGfk10CpTKMtJGgXo0LRAC70HWKAuFIc8kwDHN+EilAalvmR0EsvO4y99vcpEFKisgNorSAWg1rzI3HRIXc3eg+evuYFvn97Am7MZdkfKzinzxWNtm8MY9+sw13TULK0pOHGjeD2967j2OGH0b5bG8646eQ1OsQAP743keXzVxKujuDFFd+8/gPn7ng5r93z9mrP+fr177nl5Pv46eNf1nqOLWgmbPk8thOA2cDxQohnNtQgm7Md3rN1T/ZslSouodL+3om3Io2KlijpnGhR7q6uwqXwz9VI4SJQdSLOpo+FVRV8sHhaMhT25bJZLK9NKegc2a1X5jlpfYxdMp82OTl8fd65OCbbGm2DFfTzS4KADYurq/lhwYJG78PgUaNZFQ4T8xTPTZrE+zPW/Rlq9MRMtamx8xsfe3UYd82F7NiuDT1aFfHJ8LPX6BAD3DXuGyKuSw1RlkWquH/Sd3R79t/E4w3XS/A8j5vHf8KIce9THYs12KYFGwEttrhBrLVTrLW+CXgACANDhRCjhRDXr20/fwa65fbjyI43UqtyCHtBbMyX1vOjFI5UONJDooi6Mu3zIBBCELKitA/lEZIBLCGwEk50Wqam5aRTCPxPVUMrShqWr6hi11seZeioMVRHooz+xymEgjYikEkh3Xn7jsn3t977N/56xgCE5yFchXBsdJpyRSzaeOGWSV9MzdguXVLGofbJDJZ/ZbD8K5+99O1qzqyPXrtvW29fQeuCJp+fjosfOY8X5j7OmTetXqw+HTmFOQ2mxj57XcOFRUbd+DK3nfIA344Zx/V/uZ33n/l0nebZgvXEFm6ItdbLtdYfaa3v0lqftwHH2WztMMAje5zLjnldSNjWdAgpTE6HSDjEkLKIAik1Unp0zs0n5GgCViIpOvXhcWywLM9PhYb0D1XAaLylHGYBx37+DLv979+8OHs8F/UbwNE9dsCyBVYd0uiJ2/UBIDcY5OvzzqNL63xUtkekOI7bys1Q/l9Y0bhUZaROkaUHxn1Ht8fvpdvj97LDUw82em5dFIZCGdsJh31tURgK8fYFp/Ph8KF0bVXYpHOKgiHjSKQrdgAPTx7XYPv+bzzI6JkTeW3OFPqPeQBvC6dcbLJoscUNYp0ixcAVQBYwWms9FGhcA2YTQTQa5ZWF/0bh4UhFtuXiKlAq8aU0yXUAeYG6zqXZvzRcRa0XR4GR/kn78AgEwsIUU7JTB2wkF/fbC532CZP+kls4Hufn+Ut46pvx7NKjIz88eAkTH7+Sy087gG4dizli3x15dMRJGTN557/fIzzDaUZKKEol1g299uhG78FRfx+csW05Ep0WqrnnrEcbPT8dHbftQL+DUtzWA04ekEEH2ZDY/dBdOPyc+gml1mpKQr/18AcZ2y/e+sYGmVcL1oAtxBALIboJIe4RQrwphHhGCHHxxozYbs52GODM7x7jt8qFqchwxlGd0iOWGkh3ev32QrMsUorCQ0iFLT2kUEl+cYJv7NgeAdtFChdLuhQGbM7bfmBaP+bf0mgtVfEod035jMU15Tw66Bjmnn010866nIO7dWOH1sU8fcix7N0hla9THAzyh1eKDvnR5AAovzqIAE7u27fRe9A2JzNpbnZ1afJ9xHMZ8cXHTbmVAHw67Gws/2IE8N7Q05p87vrizkGHsl1xfcpe+5zcevtinkdVPBXEcbVi7LJ5G3J6LVgdWmxxg2iOSPEooGhdJ7CxUBFfzkOzTyIoYkgUSkOlF8KWkOMoAsSMXJuvi+lqTbaMASYErDVEXJlc6tNa+JJBXnLbcwXKFWnZz0BM4HqKRyf+iCcUCWkfNEn1Bld5lNemks0++/F3nhjzHYtWlvP5+FnMXZyS+Vm4uJR4NPPJ2g457POXXbjvnStp0yaPk3tcypDtr2Dq9zPr3YcjzxvMxY+cQ+cdOnLIGfvTqn3mn25tOeb3fHZTUrWibHlFMuJ8Urs1UyDWB0IIhj90Dg99f1vG/rs++b8G29dV5GjXtU2D7TzP44ELnuTqg29m7tR5zTLXFvjQsAVlPP8PmIFJ4hgM7AJ842tjBjf04JurHQa4f9o7/F61iPRf3XTnWGB+mBIvR0JKJsI4yXWz/i0LP4LsO8aWwrEVQiijaWyDY2si1PLc/C8RQvl2XWc45FIIqt2UpOWZX7/ITxVzWOyt5OnZY5P20VWKT5fMypyEgEE9e3DqTn2ZduFwhn39Oju/fi9DPv8vbgNJyGPPH8YB3bvRs7iYJ489pt6vcVk0XO+c1SHbcfj96suZfc0V/Hb5cA79eCTdX7yT7i/eybPTGpdoW190yivg41OHslu71IpmnhPgtB3712sbsKx6+3oWNJwDM7tyKRePH8kdv41piSY3N1ps8WqxVmWehRABwNJarwQ+8F8IIS5a24EbGeNw4CGMCuQzWuu7mqPfp2YNNQluAhwRoySaTfp6j5DSpzkIYkqisbBtyCdGWSREXNkkU419xxkgEFC4YY3yhG/ZTbRYa4WIW2gtTVuNielEDZVt184dmDZvBQEpCFgWZw/cDYAFK8t59bNfiPhalNqCH6bOo2fnNtx7/4d88OFkLEcg4yljPvjY/lx247FUl9dy5UG3Jq/52qP/zfur6lNpjh3+F44dbmrYz/x5LsN3H5E8dsJlR67zPZ7y9bTk+4qVVXzx6lgOOmXfde6vKei9dy8+VWtO7nv0p7s4s8dwaivDFLbN5+7Pbmyw3Zk9L2bFfMOLvmCXq3lu1sOULqvg+//9RK/de7L/XwfUW+5tKpRSzJ+2iDadisktrB9F2RqwsbKZhRDFwKtAN2AecLLWuqxOm37AE0A+5tt/u9b61SYOYWmtn/X7KdVaDxNC2Jjo7dPAWc1xHQ1hc7bDXy6dwmsLfzBj+Ps0aVQGnWlftTbHHAnKrM/5qj8Kjcxs56/FSZP7jAZsy+R/CJGecKcJOnGUsghKh245rZhWvoqAtBjQthvb5bclrlx+XrWAX0oXo3xH+LeyZVTHo1hSst8HD/jOczDtSuDpw47FcRxumfgJny+ZiRAwbsV8Lv3uLR7fLzPxzbIs/nPiCcntAb915oclKbWH+wcdvk73+C8fj8pQmrtt0hec23uvdeprbfDm0ac3qd11/Q/izklfotGcuf1ubJNbn3K3pLaUM8Y9BMDEMvipZBZj9ruG95f+QEmknMM67EWn7IYDG01BrVvLimgpXbI6IteRarK5Y2PY4o1gh6GZbXGTnWIhxGXA/wERIUQl8JjW+lEArfXjazNoI2NYpLz9RcB4IcQ7WutpjZ/Z1P7Nv1pDQMaJqNRDRCoLGj/BLtV4+9x2zKkuJawhZCs8pYkrC61NprNta3AtPExEWSf4yLZGJFgYafw1ieCXhUtNmzhEIi5nPvIKFpLaqggyDFIKlNLYlqRX17YAfPDhZAC8wixUVZRcKTnypD04/0pjPC8/8SHIzTZKFIAXj3PHaQ/y9evjCOWGeH7mQ/U4v9vv2oO3Kp/n01FfsNuh/ZpVveH3cbM2uFPcVBQU5/G/8ufX2C7hECcwcsSLjP9oEtHaGMHsIFVl1Rx1wdoXKotFYpza6QKqSqsBuPyp8zly2OA1nLUFYuMtx10LfK61vksIca2/PaJOm1rgTK31LCFER2CiEOJjrXV5E/r/TAhxsW8DNYDW2gXuEULUX6JpJmzudvi1Bb5DnGaLM+PEiW2R0U4I4513zipgYW2pr8ur8LQpqATGGbZEKqZsCRNRdqQi5iWqkvrHpM9XlhEWRBeSHQSNYGLFFI74Yi61rkfMS4ZAEEBxMJscJ8hj079ORpOtnCgq7NAmmMebfzkdx3GYvGoBYxaNJZQl0H75u/El89j/wzupdMPs3boHTw4YWu/evHzcKfy8dAnTVi3n1B36Yjchya0hlIZr1+m8jYVhvfdi2Bqc9JfnZ+a2LI9W8MDvr/L1yl+IqTjvLvmO5/a6noLA2gcXxq4cz0Oz/gNAlhXiyd1uJ9vOXsNZWyA2ji3e0HYYmtkWr/ERSQjxoBDiTOAyYEet9TbA/kBvIcStjZ+91tgTmK21nqu1jgGvAMc2R8d1KTLZdhxLeIDy6QzGkRRpnxStIaYs5oWXElUqGW2wpEkC0RrirlGz8LSbdIiTZtQBhEoNrDAJehH/x8DnH1sxKK+NUloTJiI1UUuhgoJdtu/ItUMPYc8+hh6THqHUOQ5VAYsx709i5coqhgy4mUVzV4KnEMJPXnEcvnzlB5Snqa0I89cOFzR4b3Jzszj+kiPX2yGuW7zj3Ls3Hq+tuVCXkxzMCuL5DxnR2ig/vNt0CcB0vHL320mHGBqvLtiCZsGxQOImPwccV7eB1nqm1nqW/34JsAJoavjpSoww/ARgGyHE+UKI04UQjwGr1nDuWmNLscMndxmQsS2EJpBcSvP1hzNaJOyxoUIsjpQmI8FCgOUrU1hCEbAUUhhusS3dDD1jx6rDSxaafDuILT1sS2HbCtsy3OBVsWpqvTBRFSEUjJEftDmic29eOegspBDkOqlgim0r8oprkEWLufHXl4jH45z5w0i8xDD+YmQ1VZS7YRTwfclcbvqlYZWcXTt05PSd+q+zQwxw7z6Z1Ug7ZTdczGlTRv+iHhnbEsGEst+JqnjyEzG3Zuk69f3M3FQydtiL8MrC99Z1mi1YMza0HYZmtsVNWTf4GugJtAa+F0L8DNyDEUU+VQjRtBTVpmEbIF0tfJG/Lwn/gicIISasXLmyyR33zNk3aRI9IKICBKRHULq4WmBZCU1LjSNctNZEPYmrU0t0CQ1MTwm0grhr2G/muMwoLeq3TjEutHFqJw0fjmdWARONUv/47z0hcC2NFxB0aJsyaBcPP8SMpRR4ZvnD8zTnDn2aspXVxhlu5B6kJ9RtCHzivsa+J+xFn4G9eKtyFIFAYIOOByYC+8AFT3HbqQ+wfP6KNZ+wBtz/zS0EsgIIKThoyL4cc9GhWD4PLpgdZLfBu6xTv4E6VaaktVlwtZodQokmvYDWie+5/2pc9LU+2mmtlwL4/7ZtdF5C7IkpxzCnKZ1rrZXW+naMYzoMaA/sBvwK/GUt59oUbFJ2GNbNFg/qsHO9fa7PEU4oTiSr0/kvKTwsoTMCFmZ8U9HOkS6J2hhCaBzpYaWrS5DgKSsEGkd49CvuyN5tO+DYnin8YSmkUGl9g20pQk6c1nkR2hdEaZ9tyi+fte1ebJdnfrODjkuW46E1TK9eyIO/f5Q8PwWd0TfAl8umN+l+rQsO7rQd/zvsLPoUtuWiHffm2+OHb7Cx0vFbxSz+Pf1JXl3w7nr3dVD7vhzeoT8CQVDaPLHH+excsC0Bafs/qZpuOe3XqW8pMt0eR6z7A8jmjI1kizeoHfb7bVZbvMZPg9b6LeAtIcTeGI7GUgyReWegGPhKCJGrte7ZSDdNRUOeQoYl1Fo/jeGJsPvuuzfZyzu43bnMnPsdWkNU2US1AxjpHxuPGuUQlB4awz7wdMBfbjNTClouYdch5vm3TAgCtiIaT6SF+NOXClTatptgwUHQsnh/Wh0tSpG6wIRPLSV4GibNXsK5977OW7cM5YZ732XOgpWIIgenypR6TtytmpoouSGbWMSFgAMxw9no2LWYhSWlGcP98dsiuvfp1NTbtta4acy6V81bF5y53SWsWmyuceybP/J2+WhC2aE1nLV69N67F+/XvJix7+a3r+Hr139gx7234/Czm1xCPQMnXXU074/8jGV/rEAIwdWjNs4P1SaFtctmLlmTYLwQ4jOMAayLtZImE0J0AF4AztJaN6ksoxAivWzoL/4rgXwhROJptlxrvd4lFzc1O+zPaZ1s8cDWO/BdSaZTmCjkIYTGFma4xLb2pyT8oARgHGVpNmw0WiviSppWIkWHM/0IpICAnfrT7t+mF6PnfZocG0BKhfJk8jxLeGQHXGI6xsfLJvBbxTzu6nsOF076N17QpUdQUB4OZtAyfi3/w+9T+0lKJlodlBI3jenbPa+AqBcjaG2YwMHOrTvy3pHnbpC+G8Lsqvn867f7ARhfNpm51Qv4Z+/1s3E39T2Fm/qektzeoaAzYxZ+ycpoOcd03JeiQN469Xvpdmdzx/TH0GiKnAJO7XLMes1zs0Qz2uI/0w775zWrLV6bR6ThwGv+gFOBHYEpWutBfuJHc2AR0DltuxOwpDk6juoqWtntWRZbQVylcYYTxjaR3KFJk7ZJiahZEoROObtC4Gc1a6KxVGa0tIxjvE/r7uhq+K52cVJtIup5/G/qDL+l+Z8AZBDyRICqcAzctKlJQMFFN79CWUlN8rxYFoTSaGM5OUGe/9/lnLXvbUSBNt3a8Pw3NwBw+5CH+eq178yJoQBXDL6dJ767mQ7dG31g22yQcIgBPNdj8lfT2OuIXZt1jN0G77LOEeIEbNvmhTmPEYvEsAP2Vpvc0Zw8Nq31Ias7JoRYLoTooLVe6hvbBpcRfIP5PnCD1rphYdWG8Rzp5Nf6xNjEvtHAmsnsTcdmbYcBdshvz4+rZuBqP3EuyRv23d+RfwoAAAAgAElEQVQ62+hEjFgnjxlOcKpPgeEOK99BFQIkmjw7iyFd9ufFRf9D+gGImCt5ZeHHJgrhV85LONHZMoCHh6ejZAdTZeo0sDhcwnk/35HhcDtWjJiXSrY7uOPODGwDj836HCkVw3sO4vwdDqI2HuWwz+6jwo0QtOJUqNnc+ttIbtt5y3g4/mrF9xnbUytmNPsYAWkzpOv652H0K+rDa/s8TkzFCMgNv5q5yaKZbPGfbIehmW1xk51inwS9Fyb5oh+wAIj5x5qrLM14YDshRHdgMXAqMKTxU9aMlZH5vDDvYpQCRRBLKlyfSqA1hJWTYWAtaTik0s921gjyZIj9OuzO24smJSMRyaiFFOzWuh1BO4uQdLi2/yB6FrSh2+P3ZvxZtNa0So9i+kZ60q2X8c7437jp9c/A9hNF4uAHQihb5XvAqV8E4nkWBa6kqCiXR58YSkFBFm9PvaPetV//0qUsWVjKnCkLkl1M+2nOFuMUB7IcYuGUpvR2u3b/E2ezZgRCm54RHvPAuzz1D2Mrtt9jWx77sVmEBhrExlKfAN7BZB3f5f/7v3pzMU7kW8DzWuu1qk+utR7UHJNcW2zOdhjg4glPMalsrrGsTWIQ+TkSGpRvTF/b5xpO+/GuDNkKU8UOihyLnjnbElMe2+V14JLtj+L5+R8gE3QKbSLGroKAlES19rvRtHEc3jnwX/x9wv+xImr4/xHXIuIZ6lOhk0tYl2ckCYZshSUU6CwO69CPM3scCMD5vQ7MuIpsJ8grB57HpRP/TUTFiGuYUjF7Pe7kpoWdCnbg4+XfJLfbhhqWWduUsCk6xBMXDSLqzQcE27W6nza5zULlbxAbyRZvUDsMzW+L1zZc1Rs4ADgfOApomgZLE+FnDF4MfAxMB17TWv+2vv1+vfwpwER2s2UMR3hkSY9u2T05p/t1ZFvFGU5uVSxkspr9rA8hIDeYRZYd9Odp2nlpAf6IjKNc+HnFEl6bPaXhiSh4b9EsAkGSIpzn7bMbtpTcPOZz08Y3uFkBi22K87ll6KF0bJumGKFN1Dm/OJf3PryaF166kIKCrEavf5f9dySYZQyAG/cYdcubHNnmfC4ffAeqAf3MzQmP/XQ3HXu2o7hDETe+diXF7TcLqdZNCgmHGGDm+Dl8/fr3jbReT+gmvtYfdwGDhRCzMA7kXQBCiN1FquTnyRge2lAhxC/+q9/aDCKEWLvSY82DzdIOA0wqmwuQpjOsCUqbozvuzocH3ujvT30IbOERtFyCtkuW7RKQLvlWiCIHv2CHR0C6hCxT1jmqwwzddn+izGda9Y8sDa+gIp5KcDXJeYqiQIQeOUECliJoeYQsxUv73sSPq35hZawkmaAXsj2KAvnsmNeFZ/e6yr8/qd8AIeC8bQ/iy0Nu5to+xzd67a0DhQSkg0BgC4vuOTlcNukcLp10Nt+s/Lw5bu+fhr1b9+evnY8kz85l25yu3Nb36j97SpsdFpQ/7DvEAJpZq/6xYQfcOLZ4o9hhv89mscVrjBQLIbYnFSmowSzdHaC1nieE+KM5JpEOrXVSd7O5EJA5yfdSaLKtOFftmMo4fWCXXbhu6g0siS4j7hpJthSzzMi0rYhW80rpuIwogRTCVz8TzK4sIVJrFERGTv+JgLQZuE1nvlvs56soEL4QdlHrXL49Zxg/zVvIs99PYMzPU5NamJjuGNRvW+4+3WgGHzWgD0ee/zhlFWEsKThuUF+Gn3VgvessK6vh27Ez6dO7I9tu2y65/8TLDufzz2cgIi4FtsfyOWYFY8aEuTwx4mWG37P5qUQk0K1PZ56b2fQqfC1YM5bMXrbhOt9IkWKt9Srg4Ab2TwDO89//F/jveg5VLYR4FzhVa10jhDgUuElrPXBNJ64NtgQ7nNY7Jp8D+hV257E9/p488mj/YVw8aSSgsXBx0mo9KK2xpOCqqQ8SI0bQTlPj0SnO8I1THiQh3nDp5Fv471738cmycXha+fxeDyGgzC3j80FPAPDWojE898fTZMlWGTMVAt4Y+K/k9h07XcR1vxrluzaBIoZ2P4qD2tWnW86tnk5JdCn9ivYhIM3qYNAKcEaXnfi+9D0CopBl8ZXJ78MrC0exZ9FAQva650P82Ti581Gc3PmoNTdsQYOIxhfV2bOBA1YbwRZvRDsMzWSLm0KfmIFZTjtJa/1rnWMbbzF0PTCz+puMbUfswFWTT0EiuWK7u+mQ3YW7+93JKT/8HU9nrMqhlTHGVRHPr2aUJiwPKC1QGuLhzFsxZu4Uxp14Cd8tms/pb4wBUgl3VdEoJzz7Er8uXo7Q8NWseVg2SD93TgjBkpWVDLjmUfbcrjMPDTuW959uXJd/8pQFXHHlS8m/yOWXHcoxxxhu7RkH3pWMbKyIZM5zyVzjIN9w/D1M/GQKbToV88hPd7B4+iJ6792raTe4BZs1tt9jW2aON8m+lm1x4j82zA9bUlhgC4LW+gYhxBBMolsU47BeuwGG2uzt8HNzPwUS0jsaUMyr/oODv7ySLlntGLX3CPq37sllvY7k8VnvGCUK0jjGmAp0SyJLqPvTJfyEaVdb1FUzq4lHeGvgv7l+yoPMrfmDdDr/xNIfeWbuU8RN5SbMwlmWP0dB9+wO/HPyhSjt8beuw+hfvAcf7v9Qo9c5au6dTK/6GYD/LX6WG3s/Q8jO4qeST/mu1JSXj+rl5EmoUil93Gq3EuEJnpr3N+Iqwu5FJ7Fj/n5kO0XkOps+HaEF64euxSNYWfsGia9zQXDdkrqbghZbvHo0hT5xIqYSyadCiBeEEEcLIZw1nLPJIuxaLIwafUOF4r5ZZplnWWQl/Qp2MstbvhGOupKw5xDzHIRwsH1ZncTymesJPGUSNZxgJkFujzYmT2Vgp670btXWd4c1KKgujzF16XLT0Nex9EKgbPAs6N+xHVPmLaM2GuerX+cyYvT7jV9TJMbV/3yN9GDzqNEp8fN6lZuDKS5Vz926c/4e1zH+w19QnmLZvJWc1OY8LtvnBgbLv1JRUbOmW9qCzRyP/XgX1718GUNvPZV3qp/fsFJ6SjTttZlACHEwRgaoBqOteanW+tvGz1onbPZ2eGrFPCxpkuQsqQlIRQSTD7AgvJxrfjFR21bBID1y8zCS4WYNN8uKkefEyQ/ECFi+3GWaAHyOFSPXiVMYiOCXJk2i0M4jYAW4p/81vkNsznOEx8g/HvUdYmOIpYQCK0yOFaVdEKJqBtVeBbWqmmf/eJCwV01jmFbxI9OrJia34zrGuNJPAPiuJJNOma7KWGDnsLj2Mx6ZewwxVYPGY3zZK7w0/wJGzzmZ52c1K0OmBZsgAlYrdu/0M50KLmOHNiPp075+NdpmRYstbhBrdIq11m9prU/BaGR+BFwALBJCjMKU5dvkERCpp/Gorv+Dr7Xmpl/vZXLFbyjhkmuZ6K/rV7YTQhCwPKM2IT2U5xGOWbieKf3suQLPk0hpaiv1LWrHI/unNKqzAqnQRdfsPBMxrpsXCaaYhw3TF/lV1ZR5fTRxJhNmpcuGZmLRojI/ip3qLi9vNctwQjDiiaGceuWRdOnbjdce/4L5vy5IO+wX/vC1eU8qGsrfulyA67oN99eCLQKDTtmX064/cYNrSyciFGt6bUa4HrhRa30gcBLwqhCi2UM8W4IdPqNb5ipq3US76ZUL+KVsBk/Mfo2VsRJyLQhIC0d6yUQ5k+ahybbjhGScLBmlOFBLlh3HkR5BK06eHcXBw0JyybZnJgthLI8spa1dQ44VJt+OUBCIpo2e+tBJC0KWR5GVm9yfbcXIt8M89PsVuGr1tnB65bg0h92gOGCSmnvk9M1oawuHE7c5jSPaH8a2oRmML3mCukF/C02ODOPwO6/O3otJKx5o5A63YHNHwCqgS+FlFGfXYxw0O1psccNocqKd1rpGa/2i1voojAzQOIwk0CaP4du9yg55B1Lk9MDTwWSkV/u2K6qiVMar0P5/rnaJe/VvjacErieIuolMOQPL9pUsBGxX0Jpzd9wbpTWe5/HF3NlMXLYELczx+TW+TF4aNxnAD5hw6SED6NImP2kbE78bw594i4vuG8OAvz/IsLtfpSaSSjTv0KEQJ2Qn1SwsW3DnHScnj4+491SkJRFCcPL5BzLo+D05/Z9Hs9CnTqSvN2ojDprxi1WyqJRze1++Nrd8g0EpxYt3vMETV4yivGS95V9bsLGx8RLtNgq01gdprcf676dixOJv24DjbbZ2eJeiHjzU/wL6FfagVSCIEOlV5jT7tNqJP2oW4/nVReO4FAQiZFnxjMJIEk1QumTbMfICMSxBsviHwERgcwMRhvU4hO3zOwIQ9qr5z5z7CThRigIRsu0YGjO+hUKiyLEiZMkYEoUjAozofT0gCPnJ2VJoqt0SXl94D4/+fioPTD+OiaWZ0d/uOX0JSSu5Mtgla1t2LjRV/I7tfAFdsncAwCHIlds/xsHt/kK+XEQmfzR1rQVWLdky7lNJPGZWvsTK8Kbx566NzWV2yU0srXzlz55KC9YFLba4QaxTKRetdSnwlP/a5GFZAY7q9E8W187lgZkj8LRECqMe4WqL0XOeo2NWW1ZGjeZtaVQa1QlfrkdrQdSz6kU2RF3HFvi9fBWXffsuD078jj9KKnwvFYj7iXbKFJaWSS1kHwF45owT2adHF47dpTd/ufnZVIYzEI17/DJrMXFX8esfy3jho/H8/biBzF1YwqW3vo6bb7Frnx706t6W008dwPsfTubxp74EoEvnYt7/9XZiMY9Lh47krQPuZL+DdkxKy8mCfNSqUtA6WUpaa40IBEBrdDzO8vklzf1nWSf8fder+cOXl3v3yU95c9V/1qtYRws2Ija/yMNqIYQQWtcjJuHrcR7cWJvmwuZmhwH6F/ekf3FP7pvxMl+tHIunTJ05R3r8UvYjOfYuWMLy8y9iaOI4EqJKAsbpDVgeCIHl0ySMw+zz0JLb8N7SV3l/6au0CxRT5q5Aa7CFoU0gTL5IjQriIilywkhfOF5gcUvfFwA4tO0RjF31ZhqvGWZXTSAojUzmV8ufZfu8geQ5rflxxf3MqXiPHbKLkdYAehfuTd/CgXww7xhqvMUAHNzmWnoW3MGKmq+YuOwoBJKc0BHJ+5NDmBqyAE2hrCHLcnFwCYo4UR0gqh0WVX1Gm6zMqPPGRjg2n4lLDiPhNVVEfmCHto1zrVuwCaHFFq8WW1kFAeGbVYGnJTUqRFQ7jK/4gZXRBbQLFnJG5xNJfNE1Ak8L4h64nkyooaVFLXRm1BmSD/xzS8vQvpFNvASJkAYI11+eIOUYj/p+IrGYx7e/z+POsw7HsVJ/ni6tC3F9+TTPU1SHTaT49Kueo7SilupwnB9mLmTIkL3Jzg4mHWKABQtLeee9SQw75THmzl5BJBzn0/cm4xYXoIvz0fk5HHH50XwceZFLHz0XJyuIzMpCBAKIoHnfd78dm//PsQ5IOMQA8Wic8R/90kjrFmxy2HKiE18KIS6pU00pobk5QAjxHEaXswUNYHHtXKQAxzJUiCzLQ8sY35X+hCWrOXabA8ixNUKY8suFTi2FTg05dgQhNBZe0pobmA+O8KO/tm+INYrSuFkRS9EvzA+fJaHICbNNsNwvL22ssfad7VWRP+iencWAVoNT9l1ASKaVg0YQV1F+KRnJzIrX8KjFVYuQ3uf0LRzIjNLnkg4xwKSSu/G8MJNWXISrK4nrcsrDL9IrsIQdAovZJlDJsG1HcdWOn9Apqz25IkIbq4p8GaG1VUlQxNiuIFXl7c/C0uqXSP+iltR+8udNpgXrhhZb3CC2qqLf7y55jkRtJLdOdTpLKBbXLuH+2W9iCXC18NsIhNRoN3WObSliru9ce6DihnusYr7VbeCDlFCeQGDyQPw2iRgHwJLSCva4/pGkPNth/XvSp2N7OrUuoF/3jpx+64uEIzGCAZshg3clEqnPbftq3GyOOnCnevtXrKhk+dKKzJ1SmnRrx+aLL3/nMuCIcwcxZ+oCPhidpthhWdzz2U0AeJ7HqZ0uoHy56ev8e87gr/9o3jKZS+YspahjMVlZwXrHnKBDPJoq1tGjb9dmHbsFGxibh5FtCg4HzgFe9otclGNkCyTwCfCA1rrliW01mB9ZTEKFwhJ1q9Npvl/1MSHLRGOFUL4qDwS0hyM9bD8wUePZxJWNRJMrI0g/Cc/T+JVKIdPKprPDFCEZq5OJrJEoxi59jN8qX0vuHdL1NlZEl7FT/kAWhyfz2bInEAi2zx9IUaAjX1VlqtdFlFl1DHt15Q015bH6ks8Scw9a21XURL6iIHAaB3Z8mp8XDwbC/n2BjoFicoOGElIb/pxVpYkEvCAd2/+KZeU2et/XBp4XA28RVqBHvWO5wcwKn44sbrZxW7CRsGXb4hBmjX6tbfFW4xS7Ksaq6EKkAAsPT6dZYZ82UO0FECikgJhORWmFEMmkO7Ot0Qo8z0LFpd+FAC1TT1dSm8xNf1v7FfRkXGAlkqN9ZSIN4MLcZWVInQrffzx1NveedXRyHu/cdS5LSypp3yqPUKChxHPNi6+P4/4nPiUnP0hNpUkksSzBaX8bwIQvZjB35vK05qmIh+eq5LWeecMJfPDcN8kvTXa+KQ4Si8Q4q9dlSYcY4OlrXmg2pzgcjnJC0VDcmHH2z71zCKeOyBTEv/eLm/i/4/5NNBxj6C2nsM12HZpl7BZsHGwpS3Za6wjwOPC4rwLRGghrrcv/3Jlt+phROQsAS+ikBGYilcHAAx3GkWYlTqXJYFpCYac50bl2nBxZQ7pzLbUiKI0NiStJWNnEMfZSJpbytKKtU0lUB1BCkq1jxJSFxKOdXcGcyhcAh4Q1nlX+Ksd2NXrorUMd6Zm3N3EVpcBphxCCbbIHMrNyTPIabRwmLtwJz9Pg0yEA2of2pTCwc8b9SDjECcRdo44UslvRIe94llaNSh5rm3u4aRP5lvLSM9J6ibKq9BzatnmN5kCkeiSRyluSV5PXbmqGw9025wgqwj+youYNHFnMzu1fbpZxW7Dx0GKLG8ZW4xQ/N/cGPG8ZkgAICwePGB7KMMkIuzZKy6RDGpQeUW91t0egfKkSYSm0kuAlCMYC4gm+cErQ2MI4zNI1bUSqK8Pv8TWKsUG5fsE7IZi1uISH3/6WoGNz5Yn7061D5hP5fSOO55/3v4NSmnaFuSxcaj4HMeCgQb3YuVcnjjmqP4GAxWPPncfN17zOnJlL6dO3M9+8PznZzzmXp2rKF7bJ5863/sHj17xEdn6I60cbjeT/O+E+ShaXZd6KZvxi3X/O40mHGOA/179czynuPaAXY5Y/23yDtqAF6wmtdRxYKoT4mxDiGMxakATe1Vq3eAtpiLhRbpt+N44QxLGwhSYkYyhslDax3UIngpW26KYBG4+Q5RrShE6QzozxyZYRkyOCIK5tAtI1zjGKbDtKAZgEaqWpVdlECZIr4zhCIUWMGhXEEpo8yyVbRiiwY2gNDl5SRzgg81hU+RwlNZ9QGBpA18KLEHYqcLJXu6uoii9mafhHgqKQrvZ0lNYICZ11DUWF/6Iw2Jt22XsCsHfHMUxefiVSOARUBS6Jwg2SbfJTSc3di29EqTjl0a8pDA6iW9EIlFKES8/IEDAC0Lr55DMjlbenbbmEy68gt9XIjDbbtb6Z7Vrf3GxjtqAF64uELa67XwgxQmt9d1P62CqcYlfFKIlNJWhBkAhhT1Im8ghKD/AQQqD0NlS7VclzLKmRaPyFO0K2SzhuJNgMtVcabrEUCKlw42nsYEsbJzlhtRTmZzItwTixoJeeIiJIe6Phn8cdyLn3v0ZVOIoQMGPhCt679VwAlpZU0LogmwG79uDtx8/nghteZnEdh7XGdTnphFS1JcuyuOW+U5Pbwy49hM/encwBh/WhY5dMcfj+g/owcvztGfvmT1uU5N0lfpAOOWP/Nf8BWtACMA9/m3dV8TXhQK313xIbQojHgBanOA2fLDfljG2psXGxhes7wHG0ht55OzGv9mff8TXmxtaKHDtuHF2l8IREIZFoCuyapAMttB9dQJMlYwSEi6cFCqMGkWMpipxScmWcsHII6wA2inwZRiMQKCyhkuNK/4HfFiH6F+zLrLLrUDpMVexXbJlHp4KziMfjwHIcpxOHdHqA6ppXKSu/nmVeokiJUbfsmncwIbtz8j4UBHuzf5ePktulNV8QcRfSNue0pIRcAtu2voVMVAOKEBbVpIIIRYUPr++fpwVbC7ZwWyyESF8yEUA/oMUpTuD3ym9TDicQ12YpLbVkpYl6YQQalUarUMjkSbalsD2PSDyQNNgJPrLWgFSgZCqLAw2uCXXImECjEVKgJSA1Qhm+m9AgYr4B9rv98sZhtM3PZUV5Nfe9/JWhWGhYUlpJWXUNhw1PJZufOGhnpkxZxMJl5aTn9QGccnT98qPpaNO+kL8NO6DJ9/HIYQfz/M1j0L6G8UUPnsXxww9v8vlrwpX/uYixb/2UjBafc/vf1nBGCzY7bCFLdqtBUAhxJLAQ6IRZN29BGr5c8U3SPmlIOrRg/l0cXuC/T31QAjLl+EkpkChyrVok2iTI6dT5ltZkWzFCwnei0cS0ScmzhCJHxv1kuRhxz8LFSibfgSZXRPyRBAWBbpza9XUA/ii5nyxtJCBrNFTFfqWs9ArC4VeTc2vVeiJl5SbK25YAETSVCGxRlOEQN4TinKbLqUqZD6IIizLytI0mSG7byThOTpP7WBNC+ddn0CeyClv0kbc4bNm2uFJrfV5iQwjxRFNP3Cqc4jynLaAJiTiWUAjHpToaIhGntbDwdBRbQERJP4fZGFEvjVvsWIpIPJGokVCeSFEkkkg4xhpDj0sYXQ3awkSMJTxzynHc/NpnLK+tzujjh1nzOXa3Poz6+CefkwZ4GhGDwZc+BWlRjDe+nEI+jjmeNoUbLz2CPft1W+d7Nm/mUiaOnckxZ+yD45iHiNOvP4H23dsw4ZMpDD59P3Y7ZOcGzw3XRBg54r8snL6YEy4/kgF1nPOPRn/Jx6O+4IhzD2bwmQcm92dlBfkw8jJL5iyldedWDRaSSBQRqRtNaUHz48l/jOaNB/xqigI+9V5f/063MEMshOiqtZ7vb14EnAD0xTjGF/9pE9tEke/kURJLyTsqP4ci4Rj3ytueaZUrUAhsoRBobKkynGQrrWKdJkGzMPZPCnCEl8HRNRZdEySGjYeH0WwvtGvJJoolQxzY+RMmLN6DuJKUebkEhEsb/TNKKaSU2NFHaGsbhzlLxLBjrxh1oTSUlZ4IQHuZg5RmAq4I4rT9Yb3umap5C0QrZHZqVS633Q9Eq+4C7RHMH4GUDTvEOj4FXfUQyAJE3j8RVptUv64LVdeAqoCC+5B2YfJYKHcYTtZZq020S5wvW+zwRoFatguJhEvsfsjWzcAd37Jt8e11Dl/f1H62ik90l5y+ZAkXKRRCQLZ06eCUsTxeSFBkkWMpyFrFsmg+EpewCqK0hS09lE+DEJglP8fyiHsWluXhupafYAfCBqM570culEDbJnQrtF/jyNWItP4mLVxKSbQWlebkouCxj35gv15dGfPNFMAsC/rSmkmHW3sglMaOQJhYUt4tgeffGMdhB/bOuA9LFpfx1KOf8f3XvwNgWZIx719Jbn6mzu+/zv8PP345A4Bn7nyf0V9dS7ttDJf5kCH7cciQ/Rq93w9fOJKvX/+BeDTO9B9n8si4O+m+k1FLeeKK0bz5kHG0fv12BvOmLWTYXWdknN9x24aT5/55+G1M+MTwoAvb5vP6shZu8YZE0iEG0DC01yWM/v2Rde5PsPkmdwghegPXaa3r1tt9C9gVQGtdC/xXCLG31nrcxp7j5oArtr+YSyb9AzCfB1cLLDS2EBTbBUytnIDWEluYcp6WMIGHgIijhPCLcyg8LZJUB4X2M0M0ATyEVskPmhDQxqrEEpqgiCVjFTU6SJAYUoImTkX1KPJEjLglybPKAE2WhtrqJ3FCA4GIoXIgsBOJfxoCCGJosrDJpwRkrj+uscYOMVB2PfFTVfs/qLoPtK9O4eyJbPXfevdLLduBBO9OVRYj25uPlZTZZBXUpVVkQqtKdOlZoGsAC+3ORbR+O9WgpD/gV/Ur2RPVelqGk2tZAbDqO8TKjfjnemZmOVcg8y5sdC4tWHeoykdJOsQA7vqL2mwFtvgPv+3eWutxvqZ7k7DV6BRbMjPDN8+O0TFYTsCqIqrLCVouXbJKaRUK0yZUQ9tQNW1C1QQsN13Mh5DjkhOMkReKkZcdxbFdAkGXYCiODPk8iERoWGIS52zle9Vmn7aNcX382x+JWApt+w9tnuH5LCmt4oCbRuLY1mqvRwNWNNMRTmpTa01paXVG+3jc47ILRicdYjB6xxeenZk8ARiH2PMgHgfX5drT1642wMyf5yZl0yzLYuGMlE7nu09+nNH27Uc+oqlIOMQA5Ssq+fKVsWs1rxasH8pWNEMFwc1XG/Nz4IbEhhDiZCHEXUCeEGJHIUT6l/XpjT67zQSFgYI6eySetsiRWVS6pcSUh6stospCaFA+9SGmLaTWSUfY8qkTlknRIyii5MkoIekChmIhUBTJGhxp2sZxkpSKAhkmV8aRKDpbVZRWPYDjR5TRmi4WtLchXnUntStTEqfp9lak/aDky6C/glg3/Q0IL8/Y1JEvoPL6lEMMEP8JFZ+V0U5VjyKz0l2Tf9cNvGWkvkweuHPrNIhmbkaea1q/FReY/hKoaaFWbFDEf90w/bbY4gax1TjFuxcbw5bwG2MatA4hiOFhmcU3ISl0IgSII4CgpeiUU0mrYBVK48u4mSiBkMIYZVsjpUZKCIY8rGDCiGWs36HRaKFRtsK2hKFF+ARgFQQvm3rFPNp2yMOShnSnE9xlf/53XHgE3TsUZVyjSFyghurSCO99aJ4oV62s5IsPJ1MbjlEXVVWRevtwXYjFwfUg7rKyCdXsfv9pNpO+MJHtw88eRCgnSCArgGXLjMIfOYWZy3x5xevOg1QGzWYAACAASURBVKtcVbXmRusIz/Oorqhec8MtGHnFmZqnN7yynqW+tf8Zb8JrE8ShZC7JfQdMA4qA+4FZQoifhRDvkRHWaUFdhERCf1wn/612q0maRAEaSVgH0MI4xa62qdVBXM/QJxxhdIOMnJnApEAnqG2gtCQkXKzkh8lYVeXnblj+2B3sIJYwdlEIKBSKttLDSutLiFVkZ/0VgHgdLyFo70VB4RPpCSr1HeOaQcm3KjoBXf0NRh+oDtw/MrdFXr0mKjq+/nnpx70YKvwRylsCdjeQbYAQiGzI+kuj52Lv2vjxBJpR5aIpUF41ymvgfm0tyK1bKbCBB6+1RYstXi22CvoEwJ5tzqRzzm5MLHmRuFa0CvVgXMkbWMJJk/jxISC95HFBMEZUhSmL5GSYRK9OAZAEQpZFxDOVlUCkHqr9vL1d23bk5zlLUif4ncazwao1itMAXdoW8fa1Q5k6ZwkX3TOGcMxkah85sA+H7r0DuQGHq+/0l8MsgVWtMr4uL7wyjs9en8D0qalIrSnllHqQOveCQdRFMCBJq4+BF4vXa5OOC/pfxdzJhspT2K6A15c+Q/e+XVk6dzkDjt6NonYprtrIqffyt05/x4152AGbZ6be32jf6dhmu/YsnmWiK3bA5tjhazDy64j3n/mUB883D5hO0OaN0tENFhLZ0vFmySgevOhppnw1jWueG84Oe2y3/p1umkZ2jdBaTwVOS9teDDwvhJijtf4OQAhRDHQHZvw5s9w8MHLPx3h70XtMq5xBrsiiIJDLF6u+IpAWfTSOsUg6umCiAhERwvFqEE5adh3UKwCiELgZdtm0N9FlExEWAkJWNl5a0DNbSELSjJWepdGq+GFa8TCq/ApU7Ud4RLHIwiq+DeH0RoVfAXdio9etlm3fyFGJzDo0c0/OSaiq6zKblV0I7Sc03L+3BFYOSl6rzr0c0epNiHwIMg+Ch2WekH0h1Pr5R85AZKh/o/NPovAJKBmY2g42b/GmdKgVh4MyEW7lDEa2emyDjbWpQgaDqKIJUHkayA7IVs20ENViixvEVuMUA3TI7sNRXe7A82K8MOdwpLSxPQ8LhecHzbVfB6nuw37brBpaBSLMqWiFhyn5bJbyLMAk3QkE9+19NN8sm8Ob02eY4h3CQwgn0Yws2+a+Iw/nhJEvUVYbSX0wfXqFlwOyxmRl/zxnMac9+DIj/34iV592EK9/8Qs9O7XmqiHGkc3PDiGiyji6CU36tO526NGWce9NJV0ZPytgc9Ax/akoreHEU/dip10yKiMC0K5TEQt+N0t+WpufhuuOvIOTrzqGfoMyq+V5npd0iAHKl1fw63cz2P3QzIpHCRS2LuTDyCtr/Fs1hNG/P8Lkb36jYkUF+5+0T4NtJn0xhY/+8yUHnrovA47ajVgs1mDCXmN45KIUVzkedbnrtIe4+c1r1mnOmzsuf/z85u1wMzXEq0PCCPvvS1nrNe6tE8d1OorjOIpPl33F6PkvYmFWwyC1mmcJZT4uCfPlE3kjBAjpXBArSFUoFTj+eq8QkGu15fguT/PJokNIBCeyCRNIC31tk3curYMdWV42AoB8IcmRJglPo3H9vrNkG9TyvSDnbET+LUhspDsHss9COH7eRkO0iTSolSfX2ydyr0DHp4EogNx/NfHORVEV1yPyrkHIOlSU8mvJ+IJVP4LIvQiy648NIPOvgPwrmjhu2nl2G1TraRB9AwK7Ip2GH5ZV1UPgrYC8a5BWASoWQ66FLVbR8UmHGID4p2s91y0FMpgPbd5t3k5bbHGD2Kqc4gS+WX4HihgCScACKcLEtYXSUOrmELA0MddDJWO2Gk8bObUeBatYWJNPzHPQSAJOjFjcQQr49vCrKQ7lctVPbxPI95kMCqwqh1hMgwVhJ8bAl56CkMTyBFZEZhbysOGCwXvy9Cc/URGOMmXBMoY+/jqvXXkax+xnHNJPxk7jlkc/QnmGtiETjA0LhB/1KMoP8uMbE8GxMwx2MOSwfdtcHrn7bcaN/ITzbzuZ4/+eKtwB8MC7V3Di9tcmt3VVFeM/XMaUr6dxz+f/x7WH305tRS25hTmM/K1+pPeK/W/ksfF3s/2uDWctrw922b/Pao+999SnPHSheYr+4qVMvvEZN53EmTed0qQxtM60Fm7MW03LFqwttmRtzBasPZ6fn5BxFsSUjSWUSYjWmoCtcRU40n849+2YQFHpVRDEImi72CjiwkYoD1sqQlYbhvQcw/TSp5HEkzGDMAECRBEoQsQJ1z5CadgjhEAKyPUd4sR8HKszIWEj1FLjQFTfj3b6IAvvSc5flZwC7qQGriwbqPXf54BXPzlK5F6IXnk0eL9D5ANUq7FIJzuzUehCiKSrSUUh/DbaW4QO7A/V/wY0hI4BUVcB0EMtPwzZ7mOaG9K2wV69PVUrDgDl11CIvJ5kRitAtp/ZtEF0dM1tWrDOaLHFDWOr4RQvrHqPsUvO49dVD1AVW0xMQxAXGw9bemRZcXKsOEWBKMVODTm++LsUCqUNxw0wfDTpErLj5AZiFARj5GeFKQxprp/8Ch8v+hXp+9KGewzx7BhkexDU4PoHLPByNG5IZ0j77NShLUvqcGWnL1jBgH88wvvjpwHwr4c/RClDwFOOSJ69444d+erDa/jqw2sIT1thIi5x36HzHb1HnzuXh694Aa1Mqeonr32F+bMWJse64eg7OTb3LNwlSxlywf4U23G8asMhs2zJ/cOepLbCGPvq8hruPftx9v/r3pk3W8Mle/9z/f5g64D/3rp6ybAXbh6z2mN1MfSWlLGXluSa51uUtZoFTU3s2MIiGC1IodYN8+Ts/3Lzbw8yYdVkNF6q9LIpn4GrbbSwiCqHmLKTxwSKHBkhKDUBAR42+GSIkIgjpEdQxsi1Ivxc8hB/lD+blHuzhKZQhMkWUQpEhCwrTpFQZGGOORjHO/FALAQEC25DqJWZF1B2PmrFISg3gqoeuRqHGCh8yDh/BQ8CDXFwc1GrzjEOMQDVsGpPlDI5Hspdglq2s+8QhyD/ERAJjn8c4tOh+m6SX5bIO5BzCVCH5qX/QJXfwEaHqldULHWoZEiTupChfUGkJOSw91jfWbUggRZbvFpsFZHikvBEJq24lVrtsaDWJINpQgghCAiFow19Io4k7NloLbCkJoSHpxUVKkSScyw0bUMxlocd388UeMqoX04oncuv5YsRQpIebBQCCCh0OCFJ4fdlAQHjJ7e2ghzQozu3Hz2YKfOX8d7E6WbRTwMKaj2X65//mBuf+Ihgqgd/ALA19OiYWQI6kXino3G6bNuGkW9fzrxpi5LHVTiMjkY5r9eVDBqyL6decyw/vv9z8vjz/3qVU0ccx9uPfIjyFE7QqZdEUlsV5q6PbuDsqZexaEaKJ63cjf8Y2nqbYlYtKVtzwzXgb/88gSMuGMz8XxfSZ2AvLGv1KiAtWDtsookbLdhIeGz280wo/QVLuvxe9RsCjZ9LnIGAiJNlp5R/hADHj/om2iYU5XNlDIHGkS4BoYh6K/m9/FWCIkbIL6Rko3B9/fk4knZC+cl0AktrFBol/Lb2Tjg552CHBqGcPSCerjPsgVoAJQ1rtCckh4TMN5vhd+o3KfoUGeyKWlY3sS0GK/qhil82cm0kkqAjUPusSZbTcTNG6EgIv5h5uvCQ7afW5y7Hp6xmrn8SdNMTpGW771Cx30HmIO1OG3BSWx9abHHD2CoixVWx2US1m1GhLldGMwyx1lAezzYRYSGwhUe161DrOVjCI5m8oAVRL8E7FvUepGIqDpgorE7m2im0JzLVddJ/BALwwlknc8/xfyFg2+y+bSdT+c5QkrF0mrKE1cADXFShYopPP59GWbmJSqRfmwD+epbRFu7W2xgWpRQ6mlqe+vKlsdRU1UnU1HDO7UMY8fwlDPv3GTz1y71c9viw1DKmFFz04NkAnHfnaRmndurVkabigQue5IL+VzHx08lrbtwI7vnqZnKLchs8ts9xjVf3q4uC4jx23r93i0Pc3GiJTmzVmFezEMuvUJdIpsssgmEUJbIsN+ksB2ScQquaHCuOSFvzlUJTaNWafUJk/JhpPNBZSDzayyrayGqKZASJpq2lcOo44gkSmxKtyG7zAU72SeZA4JC1vEIFxNDVvkxZ6Kg6xwUy2NW8DTZUxU5BxXWg66oteIjW7yDyRiAK70Lk3wjBtGqiVndkwM/jEHWq5+X9o2kzdxehSk5CrTrXFPZYH+T9P3vnHWdFkbXhp6q7b5gcGIIERaIZVBREXRUD5tU154g5rWnR1dU1rh9rXjHtmnNCRcSsmFFREUEFxYQMMwNMnhu6q74/qm+auTPMICI49/V35XZ3dXV1357Tp0+95z1X0K5KQnEnpd98yMCwnEP8WyBni7OiWzjFPfPGkqnLIBICEwkFM5bHQkT98s8ALV7AJN2JRGxXoTXElSSuLcK2m5RIkyJ1B8VcgVKp4ySVKTyRkpXAHDgoJZv27MnQ4jIueHE6VY1pEmCJoHKyZ//u9MArEHg2bDS0D4WeSHUrIOCY4P8tj56KE7ARAvr1LeG2v97PkZtfxLIldUx64XzCeW0THsr7lDIorQre+ON3QgjBtvttzZ9P353yPqVsNHY4T1b/l6umTeTpmv+x/iYDmPvBNwzbchBXPPc31tu4P3ucOI575rWWkcmOY4afybS7XuO7z3/gb7tdyczps1a8UzsIh4M8s/Qejrsmc3ruxOuO4PKnL1zpftc0vP/8R+wWOJhd5IGcMeaiFe+wBmEtlgHKYRVgh4oxQMohNalzkLByNi5FdnOGakS+jJkXcSH8Ih0m2lBqN6VJWGrivhpQwi6vY1dSIRv9ctCmXb5Q5Im2D76ANRDH3pwC2RNVd2nalrrOnZizC4ZHDCa5wyjuyLy9fHUGAThAb1TlpqjaC5Clk7I73d5yKLqc1ANDQtEVCFmGyD8CEdodISSy9GYofw7KHkFWvIT2KtGxTxE9p0Fof7CGQsldyNCfVjh85TZCzU7gzob421AzonPn3Q5k/sHI3l8DJWlrBZTNQQbK2tttrYNadgKqciiqcjiq5ZnfezhdQs4WZ0e3oE/kO/3YuPQ0Pl8+OSm10+QFafBCNHkOEeVgROSN9rCApIFNQACNcQdPpy6ZEB6etgwnTkh6h0r5alkW3V8wNl8CjgIPdl13KHfuuh+D/3198mVszB138vVZZ2LbNqGATUvMxXNAuhAUEqvFTPMRN1zl2d8vJlhsURR0EHHNWaftQn6+4ZQN3rAvz39yOTOe/YRrTjJqCtGWWk7Y5jKe/vYGnv1lMhP3vIqPX0wlgFxz2E3cPuv/+OnrRYTyQ1T0K896KkVlhWw1fnNaGls4acT5LF28DOUqLn3yPO6a3XmJNYBF32Ryz+6+8CG2Gt9Jvcx2cOiF+zH2z1vx1hPvMf6YHano1+NX9bem4apDb0zSU776cD4v3/cGux7dVlpvjUQ3NLI5pHBA/z14YfELxLSZURMCwsRwLJcCK44jU5HgqG77eBICgsQptZqRiaCBBlBYaDwFUsLggCIkYki0HxARCKEJ+DN8FhKhFRpBUfmDBLxfoNGvENfyPSo6B9nzabCy2aISoDZzVfwVw3/VHtiDEEWpqrKydBIwqVXy2RRUQ39k2W0obylUb4ch0gE0IbyF6J6fgjsf7CFImVl1NNm3M9xcg+gM9PLTQVggKxDlTyNk9lmzrGi5t9WKVaMLLHvPRDU/B7oFmd+5ROe1BSr6NsRmJJag7mII7/e7jqlLyNnirOgWTjHARuXHUhgYyGdLbyGq1+HnyE9oDa6WgMTzxX2iniSmA0mJNqWgLhYmrjOn0YWAf2x8DLOWfUdt1GWjkgEcst7WDH3qnwh8kXgfWoHR2SSpMDG6YgC7PHQPntBInYpiv/vjT/xp/YGMGT6AN+d+h3KhoDTIixccR57t8K8HX2HqG3OTN3Q05rHU8njxjlMoKWqVuQy880JmIkhzY4Q9ekygz8AKzpx0GHNmzCPSZGgUVT+aIh39h/Xt1DWd+eJnLP1lGS2N5kXg3ksfZavdO6l16UNaEuWlHoTDthrUpf3bw4BhfTny7weukr7WNHjxTDWMuprfrojJKkU3nY7LIQUhBPdufRv/+eZOvm3+gSKrhiYvihCG9wu+FJs2FDejP2xumqCI09Opx0IT0xLXd5rzrXI2Lt0b3IWUOZKy/P1ZUnszDdHFpvIdAheNDYQIknD4pJDYYiiB5schPiNzoMqvIuasS0pJwobwn5HFVxu5sLoLQKVpwOtqcEYiyx/LfvIqs7IdTbeimiZD/ikQ3BGiCckxBWqxcYQDm3TquuqGmwBf4lNpiL4F4T07ta85zzHAzZ1v3wXIvN9Ox/h3hWo9i7AWqRTlbHG76Bb0iQQGFO7APus9xezGnzGRA4EtNDElafYCtKgALjaulggEcQ/q4iHfIU45rmEZ4u4tL2FM+QY8tnA2U36czVWzX2Dkc/+gf7jE3G9KopVAKwFacPdO+5HvOFSE8jl04EiuePdNFixfBg4oK3V3xmMuwy+/gZe//Q7XBh2EspI87n59Ji/N+YYLj2w73aY1fDD7+6znvJfPJTbtNHgK5SkWLVjCPVdNofd6PQkXhgjmBTnw/JTxmvvB1/xj/+t4/4XsQvEAJRVFyWxtaUnKepe027Y93DDjnwjLXNs+g3px7l2nZmz//ssf2bvwCHYLHMytZ9zd5f7/iDh0YioakV+cx76nje+g9ZoD0YVPDn9snDZ0Avv33ZZmtSxJlXCxyLOihGScsM8flj6HuEQ00Mupx/aLdASEQgqoCG7E4YOn0C+YD9F7qW+8mx+W7IHE0CYcIehrCQbakn6WoMh2cJw/IQkTDIyjgBqIv04qSptACFVzCCzdkZS0mgLtohr+DbIYQrvSBvEv2j9pq3XxDm2O23QLBHYDwkZhQoQhlPqbVvW3opafi4o30y5kD9L4eSC7RlGQoS3ASXu2FLSlm6m6S1GVG6AqR6DalIzuhgiO96+7j3DnVDXWBORscfvoNpHiuXUz+Gz5i/QJD0FpU/EoUa7DS0vAM4w1jdKCFi+IqzIjxGEZ5MltrwPgpV++IOK5JG4fF02914jypB8VTt1SlZF6vjzirwBscnvaG7nA2DIPjhoxgjOfmJrIzUu+yS2sXs7CJZ8gPZj48HSGDyzn+x+XkphdlDHNJkOzJ7ZtOnYY5916NA9OeoGqH6rx0jR3Fy2o4sEvr2P2W3Mp6VnMEF9X+OmbpjL5HJMM8d6Uj9jzxHGcfcfJbfv+04bsf85eTJ38Mn0H9+bsO07q6CfIig3HDOPl+OPJ5a8/ms/t597PVntszqF/248Jm52H9sPuz/7nJUbstAnb7rd1l4/zR8JRlx3MuCO3Z/GCJYwYtzG2vfb8Gee0Mbs3ol6E5395iOpoJQHtz9EJU5Y5MZGWMJsOHnkyhgSK7KhfsjllU0f3OJGNyo4CoKr+NmxUsjxzJPoOpTKfMM3IRGKwEEgiFFSkVBuyV5kLQNEkqG8txagg4lcQbboD8/jMJ0NyTXTgjJY9A3VnGBk276dWG1sQPZ4H91sIbIbwnVpVOYokrzn6PKr8s7ZaxoAovgJdezq4P0DeIRAY3abNiiDLb8tYVvU3QexDKL4S4nOhJVF0qRlq9oDe3btwo5Q2qsc7EP8ArF5Ie9XMcq4u5Gxxdqw9T9NfgZ+b5zHtlxuI6yhf1c/19S0FHibLzk3jD6dKPgsyaziYhWbXYpuXL6RnoIhRZcNaHUkQUVHyZJBmnTk/8eTCLzhimFFA6F1YaKLEPkpCIT494zQAHn5nBQoMAr5vrkM7qYeDCgr69mw/SjvugK0Zd8DW3PX3x3jqP6mqQDsfug3BcJBR4zMpD3dPzJT6eeHu17I6xUIIjv3nIRz7z0P4ZtZ3nLfjZbgxl7/efTKbj2tPsqh9fDR9FhftcQ0Ac975ireeeC/pECfw6gMzur1TDNB3UB/6Durzew+j68hN2XVrPPrj7cyp/wRXx8mTUeyEOqXwEDoVrTXFOrSf6OzhCM+f8fUDDggqa6+jpuFaSuxBBHRxhlwbgBL9sFmQcXx7RZOjxTchw7ujmh7quB1gosutpsxl9jwMAGlZUGYcT1W5GZCm9hMaj7CKwW5dYbTVFH3jJVD67zZ9C6snotwEF1TD9ejqsWhrMJTe2S4fuSOoynGA77gvHZ+FW53zqACklBDMXl11jUfOFmfFGuMUCyEOBC4DNgC20lq3P2/fRVRHFyapVl6GUTQ8YoeAn/ghcJVAI4krCxfbZD1ro/6glWB5zAMkS2L1TK38mIAFUTdA4g5zlSAuXPCl3RLhjz0GDGfGooWc8/ZUlsWbUY5AeMaCX73Tziyqr+fuWR9TVBxgWUsUocBpASEkCo12QNlAnA6pS/c8/T53PfZecvnVe84kL8+oapx45cGUVBTz1jMfscm2Q3n+mc+Z8uSnVPQp5v43U8U2guEg8UjqAWVZK2bZnDXmIlyf6/q3Xa/kuYb7CeV1zRhPOm5yxvK3n36P5VgZHNr9zt6jS33msIYhZ4jXaPyWdhjgp5aFuDrihyVSTqzWGqRE+PKXQmhCxAETMZZ+Up7WHlpAMY3YMkZQQ0t8DhGhCSMI+DeYAIpYQFgG0FqjhEZqsKRl+qi/BFpal821wdkFHXkZoiup7Svzk19V5daAr5tubYKseCrVruIDqD0TdL2hOlSPMm5m/pnIwg6KBa0gGqman4Sm2/2FGlh+NLTHce4QrSLZ3i+ttjvksJYjZ4uzYo1xioE5wP7AHau644H5m/v6wUZ/2EuT7tEI1s8v55zhkwCYvXw2/fL7URYoY++3zwCM4RaIVqwzE0nWQmBbrpn+U6CUDVohJBhpHnOcm+fOINYiiSnfwZMCLUyk+pRXn6OIAI2NHr6XbuTfArDXgMG8OHe+eXj42/qUFTFkvTLe+uxbAE7ff2xyVOkOMcAJf3+Qh68/Nrl84FnjOfCs8ey18cV4voJB9eI6rjzjAf5+y5GmjzmTOLTvKcl9rnvtsg6vbywWTzrE5rpqfv5mMYNHDOxwv9YoW6eUZZWZWd1PLr2HU0ecT2NtE8dffViHZZ5zWMPRTSV+1jL8ZnYYYFTZ9rxaaabhddr/Es7xxA2nARCLNfJj5DMGhLbim4Z7mFdryrcbW6yxZap2mxBg4+EIbbTdMalxUgi0VggEjrCSzAu99ERwP6Atj9iFms0w+kOt1Bec7dsm4wEUXGA4wboZRB4UG/Ud1fwySYcYwMvkGksrDOV3GW5uTVpOQNPNkO4UB/eE6Av+QhGyMDPnog1imfYfd37H7TsLZygEJ0DTTUZurmztkh/LoRVytrhdrDFOsdZ6HtCmYtqqQEmgNxILRZyAdNEKYtr2Iw8QslMcrU1LU9P+O/fcilerZiZpFEJAgR2j0Q0a+yrAEaAtUHjE4gLLAlPvQRGPg1ISIaA57qK0lcZe14bV7Du79ToGCGRCRl6A8mDqwvkQBhkDqUBLOHT7zThs9EiUUmb6pgM0t2SX1mmtYPDdvJQ0Wo8+PXhFtV8yuTUCAYf8kjyaak0iiBO0WW/j/ivYqy1ufv8q9ik8CjdmHlZ/e+BMCgrC3L/g1i73lcMaitVkiIUQZcBjwHrA98BBWuus5Q6FEEXAPOAZrXW3run9W9phgF177c+rlY+iBUS1JIBJmGuNQKCAwYFtAdi4/CTm1d6DmSbTOLjEsPF0zOcZgy00ioS8u8b2PeCoP60WUnbKVrrvdDDCeDurszjEgCw4HgqOb2uLWytNtIfYZ21WKddF+nkCsvQG4IbO9QVGEiwyNbUc2KHz+6aj4BJovMJfCCHL/STngiNWrr8c1jysBlu8NtrhtU59QggxQQjxsRDi4+rq6hXv4KPILk/6oyHpkieiprynlnzT+DXnfHYwUxc9yneNC1B+9Y2zhh1J/3AJtvSwpIctFUHbI2jFsaTClgrH9hBCIzHJIgkenBDgOMofM0aFwh+ABrA0yf+kNlHj9GIdiqRzjAAV8CXrBRw8yjju6Ub4zLumsMW5NyEKrYx7/boL/pz1egwc1itj+aizd+vUdXz5vjeYsNm5XHXoDcRiqQfIg9/9hx0PGcu2+23NffNvXankL8dxeDHyCK+oJ3hFPcG4w7db8U45rFVYjYLxfwNe01oPAV7zl9vDFcBbq+So3QgrY4uFEOikYbOI4eBpgcDoCl87d3f+b+6+fNvwIfWxlGO5a79HsFDYeNhCgYZGAj7nWBPDIuLHeBSCPJmZIO36HFi5Sh95qeTmhC1W7s+oJVtD47Wt2uaTFYHWcmVW0iHuCErFUMvPRlXvhWp5OjWO4HZQcjsEtoeCM5ClXdONT/ZTcCSy9zf+Zw0rE53DKsFqssVrnR1erZFiIcSrQO8smy7WWj/bmT601ncCdwJsueWWnf7JIrreH4NZtqUmpiEkPFqUQGHxWtUzTFvyHCGZx3Wb3s4zP7/CktjSxOj97GVwpE5WrdPaVLTzdOtwh/b38af8pPaTxlq1s/y2UiALQNdrhDbOr2jVp/b72uDam/nPX/Zil+FDAPj3lLd468uFADQWQElpiP022oBjDxpNcZ6JgrfEYgQsK1m2+LbnzuHWy57hy09+4IgzdmLsrh0nxs37YD4X7XU1jctM1b2FX/xI5ffV3PL+1QAUlBRw0cNnd9hHDjmsRh7bvsAO/vf7gDeBNjpTQogtgF7AdKBrtcDXUqwKOwwrb4szYzEahUSjiWmHsI6jRIynfrqUoPTYpHgfdupzJq//fBCgcYSXDBZ42KCjJELNioQ9To4vI+ItuiQw5dBu1DiJX1CVmyN7p1XhrNkdiKaWA+MhODajcIXyWgx9ApC2jerxLtSeAiIExR3LTmqt0Q3XQPO9qZV1f0PJXsigodHJ0E4QylZCOocc0rB6bPFaZ4dXq1Oste5qIflVhjKnL5Vqvj8OY0AT9AlHafPqsQAAIABJREFUKKI+tUFqaPYiXPHlRDwvoUGYqdhnS4+oMqkiAo0UCiUgYAkirkXibrOkixCWMdQWoBVDC3vxXe1yhAORZAav6duzFKLQjyq7Ah0V4BonGSUQacGP056ayjcXnwPARwt+zjjXBi/O2cekjOKuZ9xGbYMpsHHMXltx6gFmWvL0yzpffefKw25MOsRY5raZP2thp/fPIQfoUuShhxAiPcnrTt8J6yx6aa0XA2itFwsherYZixAS+DdwJDCuC32v1fg97XA2SJ/4YJzjRClnYxO/qJtCUEi0z/9NJecZ3plCIBJa6QkNYzQt2iVPpieDGVtr6pkKIIAxtnVACGhsNaoVOcQJNKKqdkP2fMlfjmZulk7SIVaRN6F2gj8aCyreRVplSLsCejzZucPFP4GWLIlzzdMgOLbt+hxyaAeryRavdXZ4raNPrCyOHXQTAWGiphp8p5bkMmi0FsmI75LYYqriX2C4v9rfbtoLDQHpYQkPR7o4liIgXQKOR3E4QtiJ4VgetgVhRxGUFiHL4rrRe/JTdCleIIZyXLK+qlmAr0qhgxoV0uy00foMKi5q7ZsncdDYVJRXAXGhGXH+jTz6zqf877kPkg4xwL1TZ67U9Ys0Rc3TyEpdN6WhJQtnWWvNVzPns+DThcniHjnk4IuAd+4DNVrrLdM+bYywEOJVIcScLJ99OzmiU4FpWuvWorE5/IY4csA5ye8WHla6TdOJOTaNQ5wgHnPqnqDWDWMc54RUpkai8HTqlnG04Q8L31A2axetFZYQaCHQlCJwQA6AvCNBN2GS7Vo7xB2g6NW261RaUEJm0tKIPI+qHINyG6E2fSbNg+VtZS5XCN1M1odA7LXszVUdOvoh2us81TCHboBVaIv/aHZ4jXGKhRD7CSF+BsYALwghXlrRPl3FOcMeJygEtvZIRBqEb1wtPOJa+pnHAAIpoYfTSO9QORYuaIWrBEJCyHIJW3EsafrwsBB+FnXANnxjIeDDvSfy5QEXMecvEykP5WMbWQrcJGkYUjUX2xJ5tKWxLBg8oAIvaPjHrbH/mE34+0HjyM8LJIsaeUpz1TNvMufnTiZ8rAAnTzoKO2giL0IIf1pS8OOcH9u0vfqwGzl/3OWcvd0lTP7rvavk+H8kzP9sIdefeDvzP1v9kfZ7//Eoe+UfzhEDT2Vhlt/ut4Rg1fLYtNY7a603zvJ5FlgihOgD4P9blaWLMcDpQojvgUnAUUKI1mTQboXVYYc3Kx3NQf1OQhoXNxl0EJgZN60VDtEM3eE4DsWB7dC6AKVBao8CokiZiDCTLMEUTgsetGBKRiNKsXvPRPaei+z5ql95LtJ2cCuCtZw2cmSBtOBW+ZuZywAshZotaKvt29lodPqxxoA9vO16nx6YscpbhK7eGV17CrpmF3R8bteP9weHanwAVX8dKr4Sv8WvgPZqUDV/RlVujKo9G61bK6H8tliVtviPZofXGKdYa/2M1rqf1jqote6lte5c5lcX0KLqUbhYFuRbMSyhsKQmaCnyrThldjOto7dCQlRVk+94FAdjSKGwhDHkWgik0AQsP0KRzl+TitJAiOu+fJbGuDG+I8v7EbBsQpZNvuOwTkE+wpczTkaBJehgaqoPYPr3C3jth4VoB7wwlOSFePWkoxl1/W0MvfoGdrj1bvbeakNsJzO5BODnSCOBtPV7jt1wpa7dLkduzyM/TM7QLBYCBm+eKbtWW13HO8/MJNIUJdoc5dlbp+O5a1FN+N8YD131FKdufgEv/vc1Tt38Ah666qkV77SKMH/Wdzz576lEW2Is+aGafx11y2o7dhK6k59fj+eAo/3vRwNtuLJa68O11gO01usB5wH3a607SgT5w2N12GGAufUfAYZGoAFLaKQQxLVNXDt4uq0tKwkMRIsWlLCJEkrS3yQe+cLNGkAFI80WlL1RTVNSK8MHAmEMdSJEpx+Fyw8j5cwKCOwOgc1QlcNRlcOg8UZk2eQsO2oouiRzVVHXk+CEcBBlD0P+GZkb7C3aHrF5CuhG/9OMbrqvy8f7I0NVbm4UNprvhqUbrVbHWDdcB+7XQAwib0Bk2mo7dmoQnfz8Oqx1dniNkWRbHQjLIiwcPOI+jw1/el8kiiRRZjezzM0ncTdsXjiad5bPImFxHamMzrFfmCPhCAekSyyNkiGBRreJab/MYmFjFfducxolwTDTdjuRVxZ9TZ+8YnboM4hDXnmID6t+MoU8Eol1ErSjEMpItmkFMc84lgXBALfsvRdnPfcidRHDX/ulvoFLpr3KVoP6Mv3zBclngwZ22HB9Tv3r4Xwy70f69ChmnYrilb5+JRVFPPz9rVx+4I14nuLSR89KJu4lEMoPYdkS12dV5BWFkZ0o/pGA53kc0ncCtVWZkY9LHj+H7Q9YSysHpeH+yx/PXL7scQ6/+C+r5djNDS3INP2r5vqWDlr/NhCrj05zLfC4EOJ44EfgQAAhxJbAyVrrE1bXQHJoi02LRzO33tAUDSUipVVsoXAJEFGakDTqPqCpiryJ1onosbmPhABH6CTP2E2EEvz7zBKSkAiA+g4aLkDJMmR4e2Tevmh7HaPjG9gWYQ9op+Rza6RFe2UPKLkBqtIity13oAqPz7qnzDsQFdzFRKmdrZFWoPMXLA1CSEThGShZBs0Pg7MFsuSfbdtZPdEEMJXzgmD1atOmI6RzoFMoQvZepfVcfke0os203AbOWavn0LqBVBUu7VN5Vi9Wky1e6+xwt3KKpZQcO+gupi/6t5FCE8V83fBJcvIOTOS3zG6iyStEAV80fkie7dHshvCUryYBrd6gNI5lioJoLQjKfBpUFCFAKZhX9zNnzryXf488nIpwAYcNTr3Vz1lWafxrv5AH+Ol7UqMtIz2EJwjZNq5S2FKyQUUFi+szncalTc30KShA+cmCAOGQxanjxwCwxQaty4euHMp6l3LT25e3uz2UF+QfT53Pzafehe1YnH/Pae1qnjbWNVK5sDqjyMd9/3i8jUMMcOXBN/Kyt/Y7xZZtodzUg9XKEt3/rbDx2OEMGzWYeR9+g9Zw8vVHr3inVYlVFwVe8aG0XkqWpA2/QlsbQ6y1vhe49zcfWA4AbF72JyJeCzOXvs6AvCF8UTcVgYeNwvYNWIwAWsUpdzRCx6iJVWFjk2e5hIQJCCSSpjWpBLxmNHkCtBb0IJx54Lq/orzTkQXHIAKjIDAKAOV1djZLYzhqAQjuTJsiHwCqDhMWSXOg8y8AQFolYK0aqUmZfzjkH95+g/D+EP8Mom+AMxJRcEq7TVXsW7CKkFZFamXtmVla1qOWTkCWdyXndS2B1Xe1HUoUnIGOfQgo83IV2nO1HRtYbbZ4bbTDawx9YnXgpZ8v4LGFh7Es9gkN8S/ZrmJPiq2KNB5xKvog8NB4uMpDaUlQuoSsOI6M+9xhbfQyE+60wCTc2S69g8VIoQzVQioUmveXfs22r16WHMv85ZXs8fJk4k4LluMiLA22AluDpSCgzXepwdE0yxgx22WnQetSFAyxNNpCmtIxYwb2p7KuAUKgwuZTUtqONmYXEIu5HHLwrYzb8Rp2GXcN8+dXAlBdWcf7b8yjanFtm31G7TaCjbfdgJ/nL+GsbS/lgX+2LQRyzyWPsF/psZyy+QXsHjqUlhbzkGuszf7G/EdJ2Lvhrcs7XP4tYdkW/3rlEiZ/ch0P/zCZbfYZtdqOncBq1CnOYQ3F4pafuGj2iTy16B5+jv7AT5GFnD5kMrZPTYNkoNdYV92MxsXCJSQN91Jp6cfZdNIpTsDRGleDEnlZStTXQ+PVqOXnmn68GKrxYajurAqUwkT4WiBwATQ/2qaFtNeljcdhl3ey/w6OHHkdVTkMVTkUVbUL4Eu0xT5BR99C60wHXQgL8i4D1QzRV9BLtkTFm9v2u2RrWLY7VI9FLU13nNt5UVCrNxfhN4O9VdpCCTL/gNV2aOFsiKiYgSh/EtFjGkIWrbZjJ8eQs8VZ0W2c4s+WPsiPTe/j+cbK1VFe+uUfDC82CRBaJwyxyW72fGdX+RFkIYz+Zb4VJ2iZ1A4pNAGpkmLyRkdTUBlbmtQnRoDlRz48rRkx9RI2efYy9nnzdhY2LUEIUxJa+Il5wucVC6lTPOO0wh9PLpgHgJagrdS/9bEow/v3RMlUfGKD3hVseNENbHjRDdz8yrsrdd1uufkVqqsaABP1Pvmke1g4fwkT9r+F//v700zY/xa+/Wpxxj4/fr2IVx98O7l8/+Vt5YYeuSZVJtSNudx0kok8nPh/R2LZbaOng0ast1LjX9MwbNSQZHGSV9QTDBs1ZLUeX0pJ/2F9Ke6x+o0wsDo5xTmsobhl/hW0qNRs0E8t3zJr+Xu+wKX2qRTmJrBFIl8D8mQ8Gb6I4RBTFgpJWGSvihcK7dH+IKLPG7pE9cbQeBmwEtPXdWPA/abNauVVg1w3tULkQ90Nxpmt3BTlrqQSRO1pJP841A+oZaejG/6FXnYcuvYs9LIj0bpVMt+yXYGEIxyHpZmybar5WUgvMBZPU7EoOIesKGxL1VgbIXs8mFagZOVUmX4NhCxA2IMRYuVoNL8aOVucFd2GPlEbW9hmXUw18U39TByhUCg8baPReFr65tkI/yQghJk4EygcqYkp24/TCmxhuG8aQURFEEImnWyBcYxdz2dDpInKS0w1OyFE8v5LJJAAWW/Kz6sWM6isjG+XLTPtgWc+n8uSxiYIgyMljx52EIdMTkUxbn9jJhO225pQqGs/+fz5vsObFkx/5blZtDSnohLTn/mE0ybulVz+cNqnbfpZVrOcKTe+SNUPNex3ZtuHlWWb6xwOB3mh5SHem/IRTthh6u0vs/6m6zF0i/VxXXelKuXlsOagO0YecshEi9eckRSnNcyoeZGQMPkdjlT+Zk2Y1tHP1Pc4FkE8mrVFHsb+hlFYAsLCwo4+ixaB36xkNUQg/3SIpL30i2FQneZ42qMAAe7M1D41u0F6wY9Oo1XkNvYOxDwgap4T8XngLQR7UKqNbq0+1ISOz0U33QNWT5CDaA+y4ARUeA+IzgK3EuIzIbSbcfJzWOuRs8XZ0W0ixZuUHgokUur8jwZXLyIs4+RbcaM5LBVB6fmJeBorjQyvNbgKbKEISI+QjCO00TdWSdF5Tchy/T388G7CAZYgRWtZHn84UiNkQhjQ9AkwsqJP8gGRaLzvMw/x7NFHcOH223HQJhsz46QTjEPsI64UX1XVtDnM/C6UxU7g6GPS+G/mmUWffmUEQ0aWKBC0qehVxCkH3MJBf7qaJ+97hz1PaltN6T+n/o8nr5/Kaw+9zXk7XcbBF6bKTwfCAc66/cTksmVZbPeX0YzeYwsGjxzII1c/zeV/mcTugUP58etFXT6HHNYQaBCqc58c/rgYUTIalaBH+P9GVAMeFh42EeUkczc8YeH5/Fztt09QqfKJYaFRWtKiLYqFIighJCSY8AYx7a4i6pVF1lLNtROgYgaEDoCCv4NVkLndnQXet612WtmkqlYUDGe4nzyXcvp1dCZqyRhU1c4or9LnPaefxoboZYdD5Floug9iL4NMK24Yyiw7La11kHl7IYtOgPgsaJgIy/dDLVk1vOgcfifkbHG76DZOcXloMPsOuAPp6xODTzNI+awEZRw0eFokZdYcqbGJI3yheBc7SXOwpMIDhNBYPr3CERopFSJ5N6WcWYEpL21Jj4ST7QgHW1pICZajkbYCqbEt09/s5Ysh4HON7ZS+8rjH7+bErUdx9fhd6Zmfaaw1mq0H9mtzDTbp36fL123MmCHsvc9I068AXWBT0K+Y8fttzjr9y9jtz5vz2P9msHB+FfW1Ldx9/Ut88dGPTP70Wgp7FFLev5wnl9zJl+99QzxiJG8sy2LkjhszPf4oTyy5mxeaHiIQyD6F9PBVT2csH7/B2ewiD+Twge0njeSwBiM3ZdftcfTA09myZFuUT1kzChIuKb6YwFVm9s28h7sEhYdLKqmuiAZsi0QCSDIvJOiHPZSAOBq3PV5sVhSQFHrPgI2J0mZxZr1vwK1CllyNLDgK0hPVAHAg76hW3Y3owpjSUPE6iDTHOL4Iim4HZyTYQ4xT3vAP0EsN77d6HLL0ZgjsB+SDswui+GJSTnQMYp8he86AiplQ8TmyZFLWQ6vobCAtAVov8ekgQ1GNt63c+eTw+yJni7Oi2zjFAD3DG3LskOkMK9qd9fK3RVNC5jwexLSFi6FPWD4715KCgFSELTch3paMPiQSP0Sac235plymOca+ghsA+Y5gxm7n8cU+l3DZyL0y9pcS41RbCi00yghx+gl4gO+sVzenEiYsy2JYz/JU2p2E2miEB046kHChQ6jA4Z4TV17265hjtyVeaOMW2rgC/nHd85xy4Z787/mzOW3iXjQ1ZJY2fWnKJ5xzyJ20FJVR5xTwyB1vEnNC2GVlWKWlKEsweORALMuiZCUl4qp+qOH6E7PpgeawpmJVF+/IYe3FkQPP4NTBf2fD4hHsULE3QZFZvMBCERIxQtI1c3AaJALbVzZ2CZAeAC5IL4SRRvVa4a0UOBN6fIDs/Y0fdc3mRK+gsEIslT9Bwb9bbcxDFp5i9IwJgDUEUf7AikaVFdIKgz04bc0SqD0RWf4osscLWagScVTj/RB7BmiC+Gvo+I+gE1JkEkI7+X2XmP7bQ0e818YbV+Jscvg9kbPF7aNbOcUAARli+15nURLoQ7EVJt0ItngOAoUtNJZQ5FkmQmxguMFBacoza3+LSW7OfKUaXrReUpHCkir5MdCsX9CLw9+7jau/fA4HieuXJ8VPMJGSNFJxFj6cMCOoam7ksS9n88TcOfzUVId2QAcAG27/4EPOenoaTW6cZi/OmU+9gKtWbi7k49lts40bm1LVoAqKQhnbIg0R3Hjquj5722u0NJoy0UJKwhU9KCov7NSxT7vp2Ha3LVpQ2ak+cliDkMhoXdEnhz88hhRuwvjeB1DT/D2CEK7/sws0ISuKLbSvMmHRooPY2ksGDyI4fhK0Jh+XgNSZ9eF8qle49N6OOcXuC7DsQFT0XfAWt9OoA2cRIPodyq1G1d8MsdYFAJehIjMg9iYQA+8ndMPNHffXEeJzMpd1mg0Mts7VcKAxvTCYMvSH9GW7cwo0MjAcxDpdGWkOazpytjgrupVT7Lrmjf/Nxdfw2fLHaVS/EBYuYWKcM/QFHJlPYvpOJIt1pEcONFIoHOn5UWCjShGWcRKOcaEV4obNz+WGEScg/cp3AnNv2dJDafiqYTHV0Qam/PwJd85/3dc91sljA5Tnh9h34Ib0ycvkqGltHOKY9Njq3tu58K2XOf/N6dS70fTdeWXhdyxtak66643RGI3RLJqaaXj6vS84+F8PcNVjr2asH73F+m3aFuSnHOEbHppAvCBAvDiEWxKiV+9WygYqM/rSlaIR+562O6+oJ3ii6i5G7rxJ5hjKcgkfaxty0YkcwNjiRreWO769gAXNnxDTcZSWDAhswSUbTyUgVDKwYFKbBap1gEBrQrg4wij3KASRtAd5KP8CnPBOQAdFK9S3oH6C5ceSUmlohcLzwdqZrAEKAPd5qBkLzbdCw1/bbq+/hlTwJQLul+2PB1CqGbXsbFT1XqiWDzI3BnfMXJYbpL4GBoG9ddq2oe2POYF426To9iB7vQk9ZkHpp236Ve73ne4nhzUDOVucHd0ilT/i1jHl+11MzFdDo7KBACDwtMRDcsv8PfEIILB83QnzR5+q+mIoEJ4yPAgpICA8Yp4AYeNIZZQnaOKAd0+nLm4REBDVNhqRUpuQfh8+auK1RnlC+4NDIIRmeayZSzbfgY8HLOLmL95lw+Je/LC8nplVi/wMFD9enYiCOKBj2jjzwnDvgkEL4RnCx0Z9elIcCrZ7jZ58dzZXPGbkeL5aVMPUj+bx/iRTSrQgP8RNVx3MP/71HJYluenKgzP2PfmkeyFgkziDN75YRDg/SEuToVVsv/8oZjyeMu5/2q/r+rglPUoo61WSse6z1+a00zqHNRLdlKOWQwpP/PQAb1RP99/fFUXS2EQhNEEZ55f4h9z81RE4WoL0fM6xuWlExg2kyZMuEqNTHFOCkFDkS4uQsIwdbL6BluYpBEVrWkF7KKBNlTOAyJtQfifUXwrRT6DobKg7o2279qC+xTxv/EBC+OCOWkP1OMMLBqg7CuVdhCw4BgBZej1qORB7C+xNkeX3ZO7rfph23C8hfAq0JGhmNog+oH9KtSk8ufPnAUi7AGySUfokWqZA4dld6iuH3xE5W9wuuoVT/PrPE9JrC5EnPeoVKA1eQttBe+TLKM3awfV5xUpLXCxEmiG2paTFSwTYBY4ETyXUIkxfrtbYQqMtgcbD87ltrpagFekhXReXzcsG8nHNT5BhaDTbTLsJN26O81V9FXkqlHpBbx00SVWeTqLejnPL7nviacX4DYZ0OI34yIzPMpabY26GBNrIjQfw3AOnZ903Gs3k3DU3RXj5sytorGshXBDAsix2/csoptzxGlvuvDH7nthWnaIzGD56CK89lOLv2YHVVw0uh1WD7pjNnEMKb1RPR5KwdJKYtgjh4YhUvkajt5SgdEAbpR8bRVDEcWTq5hGYiLAjdVLC0kMQEBIhzEyf1hrE94DTucGF9oHIw23Xx2dA1QYkrWtXHOIkyhBFp4E9HBHYrOOmCYc4gcZ/ge8Ug3GMOw3hQMU8oBFpmfwNVXetkW4r+BvSWllKRB4ZLxBy9eqt5/DrkbPF2dEtnOKYSvzxmiiqCTwoNFZS7kwIox8spSCAwtGKBmWiycLXz9QZiRspB1NmmWNIGGqFNFOAvoHXlsDB0ChcD0aWDeHg/tvwWe2jgMbzRNLB1lpj2QKlQCtFo46Q/MkSfnUa9Vg5GuFinF9/W2lRkG0GrLfCa7Rh/14sWLx0he2yYezYobzzTkrEfrfdNgWgoNhw8ZRS9B7Sm0vuO5VAF3WS0/HFW3MzlutrskR1clijkTPE3Rui1feEUyz9NYmYsNCgpTS6P1qQJw31K/29XqRbY5FSpkhM9HVNn1giQtuhY7NAfZVl+68Nq1Ui8lYQIW4XXbGZrSK44ZOQlgX4DrFqgvzDkXb/lRxLAq2UOJr/A/mruVRxDr8KOVucHd2CU7x9r8SbtYkuaCDgx47TVSNamz0hTEUlX+QHIbSfDW0UNY2GsTbV7ZImWaO0iULrVn15Or0QiJFd+3TZAq6d+2SbsfitUusl5Ads1i8qSW46cuNNsS2ZetJI/5PWx40ffsDp06ZSH4nQEa44YjeCaZXkNupf0elCGSeethPrbNSTgh55nHzKjpx7firho7Ehwp93ncQxB09mr3HX8v678zvVZzbEoivIAs9hzYYml9zRzVEWSEmWaTQWJBPs0mfQ7LQEZ2Uyi2lRjq/6o7DxaMQBNEKb3I0A0KRdVEKFR2vsTj/iFLr2FFB1nWsemkDK0AbA2opMlz/LEZYdjWr834r7Lv5v5nLJ7Z0bE0D470AJMBDK30Y6qSi5anoYqkZCzThU1ViUWpX2tCvSdzn87sjZ4nbRLSLFZfnD2K78Ot5eegGeFsSxUGaCjWRYARPVBeU7tBLL18m00jxNpTUB6aG1cSAt4eF5gqDl4apkiAIhbLQy0YzWzrERrhe+OoWmzm1EiCAgkFKjlEiOK/2+nLb7CaxbWJZxbv0LS/nf7E9M8Q6h0bZGKxM2kULy8S+/APDujz/w6cmnZb0+sZjHdtfdTmOeh1Bw+1H7st3wtsl12fDVd0s47m8P+icHr8/5ngMPGp3cfvdtryWr32kN11/9PE+8kCUZpRO4+LGz2KfgKLSv/L/9AaNXsEcOaxq6Y+JGDilcsfGNXD3nfBbHfsYRnqFHJIISOi0oIEBrZQolCddXBTLtATQCV9tYRJOcY+Wvb9YuhSLgTwyKNAvfGbSnQJGOPGTJecB5yTVaLUPX/hVis4B2AhCx9yH2Pko3IgvPzNpENT8L9ef7SxXI3u92euSq5jBwP/aXakHVkJFk2HB1WuNqaL4PCo7vdP8ZyDsZmtMkMUv/237bHNZI5GxxdnSLSDHAN01PAcKfqJNoBLavRSxQCK2ReKZCnV/MOSA0ViLJI6EjLACfEpHUJRYaTwt/nSZgadbNy2NQQSkhX9ZNkCjakYCvciGESdqT8eRxAo5HwPGwLRfL0ti2QgrFztNvZcgTV3L9569z6Ucv8fbi7zhpxFZ8eNQpDCkp9fWMgYCGUIqbDJq6aIQNbr0h67U5/8lpNER8x1XCmY9Ozdg+/5cadr/ivxw86UHi8QzhI665PVOC6POvMivOSZn5OPo1JVdDoRAvu49z1bSJPPzjZC55/NyV7iuH3wm6k58c/rBYEv8ZKYz0ZcIcxLSNQuBpsHHRaILCIyg8BIIWgn70OBVNttK5Ywg8BDaCfGwTUU4EH6xhtKkG96vQ7Beu2AzVeDuq/ho0Ell2L/SYkqV9K/nJpltRtRdn77r+wrSFalT9/2VsVnVXo5Zsh6rPUmQj6RAn+prYqkEr2ytWPiYmi86BHu9DyR3QYy7SblssKoc1HDlbnBXdxin2tHl7N06u7wwLjSM8gsLFiEpY6LRQhRD47cyahJ1N0CYSEVxHeoSteLIktNawJFrH4mgVQUtRGIibvoQibMeS+6djYGE5D217HMeuPybtWDLpaFu2RkgzdXjbV+/y4IKPOfrNR3niu88BmLjNn1LPiyQdJI00JCCiFIc9+WjGcRsjEb6qrs6Y/HK91H41dc385f8eYNGyeuYtqmbLC27N2H+dnpnFN1r7vCectjOFvo6xkIKJl/2ZX4utxm9ORb8ev7qflcFP3/zCI9c8zU/f/PK7HH9thiAnA5RDAjI5g6sApQUxZeNqiSUhIBSWL7WWsCkKkTGbK5OzcMam25hMkQgeHgpHWEgh0N7XQBfyJYo+gaJ/kb26XTpaoPF6aL4HqrZHqQjSXp82TjANbXeNPIHyMikHKvol0IroqVI6xGrpBGi1CIVQAAAgAElEQVS5F/QSaL4Ttby12kMr42u14g0X/zP1XfaH8JHtnFfnIO1yZGhHZCdpdqsaqvlFVNODba5jDitGzha3j27jFG/fx7xxW0Lj4IEwPGATM9YEMfI+IeESFEZ32EiepfOFwdO+EyxjhGTUxCeE6TdoteZo+VQKABS2NJHmsBNHJh1jc/yndziXEeUDyLMDbRzLhLGTPrfYfMx4/jvPSPBs3KN32h1s7mYd0GihM2zl+78s4k/33g3Ae9//yMgbJvNdUx0qDxKiGkduMzLZ/rbp7yW/G5ccTrjtyaTm8zXn7UtBXqra0RVn750x8ry8AE9PP49nXjqP6TMmMnLLgcltF57/CIcdfCsvT5/d5vdaE/HGY+9w3PCz+N/Fj3Dc8LN447F3fu8hrV3oLIetG/LYuhPGlu8CQFxLPJ1ydI16jkQrTQyLBhUipnyjpCGiHN8xNjY8KOJEtSSiLeJakhCcjPsR5YTl7dLclNwImVeIzNuPrvFkIxDzbaXVyahp9Qam4hygqg6A5fu1aiCgMC2iHH8rc3N0GqrxvtRycXpluUJk2X8ymsvwftDzK+g5C9nzNaQ011ZFZ6OqxqFq/oxyO849WVOgqvaA+rOg4Z9QPSLnGHcVOVvcLrqNUxyySzhovXfZtte1BGRfEpHghFCD55d2lgIcoXCEi0Mee61zKv/c4AFGlYxKpOYZ51SYanZhyyUoXIQ/FSgyIsDG6Q1ZAUqdIkAjhcaSUBiME5AutvDYv+8WyT2OG7Kt2VNn9pHZJ0ke3aBiEzHtWVAAslVbC7SVLP6cXP1jQx2vfDefc6ZMwz8lAFQAvAD89+NZjJ5k+GLbbrBe2lENPlzwE9tdejsPvvUJPy+t4+V7z+C9x8/lvcfPZacxQ7Ne/4LCUNIIAxyw3418PHMhSyrr+dc1U9l1x2uoXb5mq0ncdtY9HS7nsGLkohM5HDTgOC7f4BYO7ncSjvCwWiUYO1KhtUlfbtZBlBL0CA5lXP/72bLXXRQ6/cgTcQIiwRY21Il6DVH/3klWCW2NvI45tLLnM2kD2b5rJ2b7smRyUOf3afR5vipbYEBD9WhUw23+cpZiRY1XoZZfgmp+AgK7Int/438+yXo4KSVSpgpCKbcalh9gCpi4c6FmU1TNUZ0f/+8FtSBtIQrRF363oaytyNni7Og2TnFV80zq3C/5vv5pCmyXcitVCShRNSnJdxUQkh798nowJG8zrv76UL6oewc7jfaQdKhFYipCoTUUWxajyzchLD0EHgHpomlCU03IcrGll3RoA7aHJTX7992Giz//H5d8fi82gum7nEWeYwMu6e6oxiTmgXGaNy3rw3tLvmXQY1cx6LGrwPYMnzj9V3VAB9NcYv8UI3EPO81JTUrV+duXt0R45vMv2WnTwYxYr09GO4DGljjXTZnBHlf+jxdnfd3l32P58lT1KIHRep54weNd7md1Iq8or8PlHDqBHI+tWyPiRni/5n1q3OVMq3yedfPGGBGxtCJJQBplTRDV+ZSFtqCy4RXeqzyZhtiPKTZxmjOtgBipyHDc+TOIVtXsmjtKCLNQkTdQNYehGu9Dlt8Ngf1YMY3ChuCBRtWhcijEp66gfTo6cbM3+RHg8jeyjyX6GNRfDNUjux4xbcryYu9+gPLWMnqY3ff3HsHah5wtzopu4RRPXbgN71dO4M1Fx7Ak8i7N3s/E9SzSf3lHpEo1J7QfqiLzueXbE7Hw0EgC0jPUCx8JjrFC+/QJD2E18kX9TIJ2jKBl6BlSgGMpLGmKeiQyqAUeoDh+1vW8WzOHt2tmM+6tiSyN1FIRtikMewSsOEIoX8LNj0YLxUWb/okix6HejZAYhQz6BAcr7U4W+Al4PpUCKAmG2HvYcB447C+pcxGZfwEauPP9jwC4/6xDOGOPMamnTas/lGueegOA+uYIVXWdi/a2TsAD+KWylhef/5Rdxl7JLmOv5KB9sicG/l6Y9MZl2H7lPjtgM+mNy37fAa1t0CA83alPDn88zKmdwymfnsKdC29n0teXszRWzZzGz2lwjR48GCc4rmRy5lagiRNnbu0jfFV3HwoISU3MT7tLn921gAIhsBAoAdHY44Z/22k4UHuSSVhrvApVcwiED6djGoWEivch+kRXL4dBnl9RLjC+w2Yq8gbSKUb2nkeyMl4bRCD6nGnvLkKpTlAhguPa6Wo2asnufkLhUFT9zSvua3Ui78TUd3sUMrBF+21zaIucLW4Xf3inuLLxLTxtopIqPQsNk+Wc4BUHpCKYLqWjSRbRMJFdw1MLWso40FoZV1QLI+UmEkbdZEVHEna0FUE4kThnypoqHGGc5oSPqNGc9slt1HrLAQg4GilB+tQIITSO4/Lvr1/ng2XfYdkay1aGYyxAhhT5YclT+x7GoJI0+TYH7txzH5476HA+nWCk2dbvUc78iecQyJPoAGiZYFKbvhYsW87fX3wFgAm7jGarwYYrpyR4QfD8/IpwyOaGZ2ew3cTJ7HLpXRwy6aEV/i53/vd4pJW81ADUxWL833WpabDlS5u49foXV9jX6kJF33JejDzCK+oJXow8QkXfVZnR3k2Qi050W0z+1lCyEgKXSeUJbDT4lT8FdV4YpZSxzcIEKUIijkKYss4KQNCgQ8S1BK1xUASFqV2XmPFzu6yd28qJdGdB3QEr2EdB9Tbtb7ZHQNkTZDKby6D0Iaj4wKg4ALLsZiie3n4/tSehvBbzvcfLtO8Yl6KqRkPNjlC1KarlmXbaGcjQFhDav+2Ghr+C/ja13Hxr2za/I2TR+SmqSI8VP29yyIKcLc6KP7xTbMnWPKzUrywQaQJtmmCCmuBvV9ooTdhCkW/FcUQMfAfaES5SaGyp2/QLGlvIROyDRMEQMILyQkNAeFgSHNskrJmKTOZxIYTAlmZMQkDITkWxQWFJ8JSCNEkjKUnymqMixsiKddiqXy8KQja98wv47677s+v6Q9mkV+821yjiT7mpMCgbtC3QFiBNMl4C/z31QAJFNjqI4Ss7oC24++S/cN/rKQ7bvJ+q+HjBzx3+LgMH9uSV1y/CC0m8gMQLSXMSVuZLxPff1XTYTw5rF3I8tu4LKczjRrdJfdN4fnjC80shNalQ0i4HiCcpbnEcllJA3DNBiwYdJCQVTquiRasX8fY3yUKQxSDXB8LgjIaeryKDo5BWpuY8kVs6Pow7x3Rp94ayJ9tutzYB9QWoZal19ZetcPSy5FoI7tb6YCvcL4e1GzlbnB1/eKe4Im9LgrInkF4lSWNmBTKT7RRg4xm9YuFhSxcpdbJNQBqZIAuFLZVJEsEjIGLJfo3JN5LxiSi0FAqhU6VMhUg4seBIneQYt4VZH5IWtqVxbI3jR2cdKxVpaa1WYQnJxA9f5NGFX9AkW1iil3P+h8916nppiwzFit2HZybOReJu6uEjYMsN+tO/orRNP/N/qaFxBVX0AIqK8zCyHObqrNunJDUWYPbXixi30zWM2+ka7rv37U6dQw5rMHIZz90W5w81RSk0gnhSdUITEvHkrByYGT0HSZQgoP1gQcKZNm3qCeMikCgiWhJVgriGqNZJfnI+gTSu8qpCexHadiCLoWZvUN8CLRD/AJraoVq0R2VIwN4s9d1tW4paVjxFG86xBhXJnnSXgfwJrTob3KpBOEWlqNxgrVGpyKED5GxxVvzhnWKA8eu9zJ4DPmDvdT8mJAqTFeWSer7+Dz++300MLBiDLTzjyLYKPYiEgys0ljDR3pB0CVtxwlLj+FN9QoBDolqTIiA8Ch0XSyjSdShT95xxps32xHcoDXns0HM93t39CiNXlHaPyqQz7esl+1XeLCG4bqu9eG/JD/6rnjnV5fEWrvrktazX58EDDkie6cAeJew1fBi9Cwo4ftTmnL/jdhlttxu6bsbyX3cdC8CE8Vsn1ykBVz/7BmMunsx/pndckWmT7QYSKbOIltpMOHVH7nnkNE44dSfGbj+MEaPXx0vjNN1/f04CbW1HLjrRfTGgYAD3jLqHySMnc/bgcxHCBCoyXuo1FNsV7LzOceSJIGhhHOa0Nlqbcki28AiJOK6WxJA0aYvlylQgtRA4wvpVxYJSsIAwFN0L4SxUg/YgK6DgUiCaub7pmuzN8/YCO2VHCZ8FciDIdaFsCtJKSV8SHE/G41v4evF5E0CmJxe2QO2hqMphHTuysicpdYsw9HgCesyEwO6QdwqZ1BIPatcChYocOkTOFmdHtyjzDDBv+Y0srH/YX3KQQuBojziWb5Q93qu8nFq3Dhuw0USlAOWRsMhCCMK4eAgi2sYWyVxpAnYL9fEg0lc1lhZInVn4Y8J6f+GlxTP5pmWRMfZoNJKQ5SX5zlq5eNoIEivgs4Z5XDv3QTYuLWJh4/+zd95hchTX136ruidulnaVkVAgiBxEFkmYYEw04Uf6TDDJ5GRjwNgGDNjYZAwYjEEkg0UyYLLISSAhECAkghKKq81hYnfV90d198zszmpXAaGw53kWTXdXVVfPNLdv3zr33Dqyjk3a0+4M2y5Kg3IFVkh4ZVElf53+EnVO2nsg+CQOzZS6QkrDB4vm8VndIsYOGsa3F/Ws9PKIIdVMXDAXgOFVlWy5wUD+/sb73PHBJCiDqCNQ2dz/Sf949SPOPmC3omN9/s1CJk76BoRAC/j7hHc57uAd+L/jDUfvggse7tGc1ja4jstTt/yPWV/M46enjGOrPTb7sae0erCectR6UYiLPruQpEoiEdgWONpC4GJ5seAWZykf1T9DQieBEAKN7bqUySRoX2te0aainsSlA156tIukTmlqLEFGO4S9R1wn57jqQWg8nS5LMhfABZLQchJU3A7JJ+nk6BaDaof6A7ttpnUakk+BdhB97kLkSabB2UX7SCuMohRoMTtKrjL/1u0NqlhyoYbm86HvP4pPoulcoN3bSELz5ciqW6HPreZS8ks6A+h21gVoZx66/V4QJYjSXyFkRfed1gX02uIusV5EigFmtz4a0CC8vGUsYSrbGZqDIO3WmpLMnrNr4RIXLjHhEEIbxq8wRjks3IB2EfIitoOipYwsHcX+/fYjnCenprWJME9Y+BCRcCP/HXsXR2/wU6THO85pG2uEf5IAmlcWT2VeshbLUkQjGSpsEzEQXmTasnJJfhmlaMi0IywHIXNRaSHg1E3HBNsvzZnJya9N4G+fvM2RLzzCtLpFPfoe7/1oShB9nt3UxPPTZ3DHG6aACBIySvf4/7W6pkKlClcV9vxjh+p3u+62UQ9HXrNx3+WPMP6Pj/Pag29x+YHXMnf69z/2lFYLjHSh7tFfL9ZN3DTjJpIqCQiPXGbslqMlFsqrOAqLU82QZx0VkFAR0oQJCxcpQCNp1nGUEgVts2hce1uc8C441jYoVGcaReMvoPRC5ICvKar/2xWazyXnEIeX1RJIgO4+J0I3/BLdcj269QZ0w7ForbrtoxrPIXCIAdouQDVf14VD7GMZ0nK6ucMJGgq3ox0SDqvuZG2H1ml0/dGQnACJh9ANy9awXpfQa4u7xhrjFAsh/iqEmCGEmCaEeFoIUdl9r57Br77mw/ak0HIvSzknVKAR+LQHhS3cQEItB1OEw8w7tzdmRUk5s5nU+AyxUJa4lenUdmm6llMnn8jE2ifpE27Hli6WR7EI4Rpnu8NrXEdVlCNGbMmVm/+MmPQfBsVf+8JhN++Y5u8zcvSD5+bMIOU6OFqRdh3Of/s5Dv/fg7y/aG4332Yh3p9T6NCpUGG+yz7bjGLXq+5in+vvZercQu3L3bcdRVV5LNjef5dNC45XVpby8iu/5uyzf8Jdd5/ENdd0lwm+dmDqxC9IJwwPXUrJ11Nm/cgzWo1QPfzrxY+CH9IOAyxJ5zttkoQbQgqw8n50gSmmZNxejQWkVZgUYbLK6lAgCVSeEfaT+DKU05J+k2z2I1ytULqIY9x2vdEVZkWjnhnPqd6g25YdoTKzzXx1BrIfYyLWaXC+Rdcfhmq6CK2aux4g+1WRQWuXcUYJZFBLtkU1nIbWycLDZZflbQgo+01h78rroO//oPQyqP4EaRfS6NZKuItBJzEGJ2uKl6xP6LXFRbHGOMXAq8AWWuutgK+By7pp32PYto0kFLiHJsJrZIBEntMo0PhMYj8KbAtDbLACeR+TeKe0cUa19u8bwdLM9yRVC2HhYuMQsjTloZSRFcrzFIXObVeGUkZyTWgsSxOWWYbFY4SwC+YVklmiVpaIlcXSLp82z0RaAttyPadbFDj4wfmEkWuzOhBlxvQbTMwOBdtzWhqZunQRv5z4BPWpXGENRykufv1FfjbhQZ6c+SVWh2XIS/fajdEDa4LtUFjy6Q3n8b/LTmbi70/lzZmzaU6mWNzcxvkPPdfhd5E8d9sZnPf/9uCCk/fiijP2K/rb/fyIHdh444Gdjq2tGHv4jkRLIiDMKsLmu27yY09p9UCDULpHf7340fCD2WGA44ce733y8iEQWEJjS2X+f8BEjiWulxJhbJuLhdKSLBZJHfIcXC+ZOS/ZwkYRQpDNTERpTSMZXK3RK0ottotTv3yo9ke8JOHuCnx06gmAEGGvLLSF/zqAMwNSL6ObLy/skfkSVXc0qv4kKLmgw3h9ofwKCkIS0YOhehpUvw6lF5gkP90OmQ/Q7eMLesvoXtD3ZcNJrnoYGd6y04xlaCNk6clIu7TTsbUS1kCQlRgWaQTCO3XXY91Bry3uEmsMp1hr/Ure5ofAKg0LHjB0Eh8uPp2GzGQQENFZEkiksNC+ZJqAEFkUNoFKhNYepUIgtIP/HhGVCqUFCW0ZbpwXTc56zDgbjeMZ6rDMklbGATWjked4aypCCdIqhNbmnK1uPRVRQVPGRFFNkQ9zDA3/XfQOjrII21AZ7sN2VRuRcNv5eOlc6lMa3zCOKq3hW5YG/W7Y4ZDg+zhx9Pa4SvPhknm8s3AOaddE0yWCxe2t9I2aam3HPfsfPlpkuMgXv/4i9x19KA988Cn1iQR3HXEoFfE4T/3qBF6d/g0Lm1o4YadtsCyLodWVzG9oLogat6czdMSj70zl769+AGhuffF9NhlSw+/+7yeMGvjjaAA3LGlm8sQvGbhhDVvu+sPQNY674ggGjujPvBkL2POoXRg0srNM3rqJ9TObeW3CD22Ht6raiis2/R03z/wrGZ0CAUpLXCFB+5kVCpNxAflOnvYCBBltUSLdQE6zWUextKJUtiOFxkGjtSDq0cuSOEQJrVjSnfMeMBDogl7WelXus9wYovtA6kVQcylcvcsfoxwZzpWCFn0eQbfdDM58yH4JJDCRy1wpY6XaoeEIgtCdMw0q7jfnD22JrLrRtKuZAslHILQNMuI7eUNQqomczJoDqrHgMrROQdNZoBZD4l8o2Q8iu0PZVUj548TOdGYKOHMgMhZh9e+2/fJCiDD0fQqdeBwh4xA/ZpWfY81Fry3uCmtSpDgfpwBFqzYIIU4XQkwWQkxeunRpjwe0bZvGzCeBqI+ULmWiBAtDX5BeZDjsL8BpHdwzIaEokVli0iEsHCyv4IYtNKWWgy0ICnCEhYtf2MPA6BqXWGniMoMVFCL1osBCEZGud23BNQIwpnw44GJL84cnZm+q5zkI4SBkO7XpOj6on4kjU5RF0+w/cGP+ucsJDC/vG0i/CQm3zXgtmJUUglO32IF/7nMEx2+yDXE7RNwOMaiknI0qq4N2U2oXoG2F9vjJr86bxUPHH8ULp53IsD65ldV9N9uIdpnl3BdeoLbNcIUHV5UzbrORREM2Edvi3P06i9zf/9rHpLIOqYxLIpNl6qyFHP2Xh0hlfnidzJmfz+dPFz7KA7e9glKKprpWfrXHNdx12WNceeztPHffmz/IeYUQjDtud066+hiGb7kOLEMuB1ZXxrMQoo8Q4lUhxDfev511A027oUKIV4QQXwkhpgshNlz5s68z6NIOw4rb4upIX7KkgtW4djdETJQF1IewVEghSKlQnjqPnwtiKt61qTiOsswDTAtcJI4K4RPgHCCtTejZXunH3CIofvsUInoQJO4GNcebsw2xM6D6AyCf2tCCyn4TbAlrALLiL4iqO0GWAHEgBvHjc13SH1Owlq3bkLHdkP1eCRxiAGmVGv5v+yMFVehE/HgQ5SBKQJQj4icUzj0zxTjEuh3jNC+E5OPQ1EGq7QeCarsH1Xg2Kv2+2U5MQDecgm69Gl13ENpdFjVkxSGsvsiysxAlJyHEcsrtreVYHbZ4bbTDqzVSLIR4DSgWFrtCa/1fr80VmFfaomVqtNb3APcAjBkzZjl/skKCjEMLeFFh79wIARGVJSOsQB/TnBeP5aZzowiQGu/OyedHKGxtJNaS2kSILSFAKEoAx3XRaELoPDpCFq8ek39Gtuu7EbNTc0m4JrHD1YK0a9QyhIaIhLiM8G3b4uDUUsIXbd/w0Wdfks5ECq53Saq16Ldy5Q7j2GvwCJozKfYZMpKwZZYC758+Bcd2jX2XoF1FSThUdIxx//wnc1tM4sfL33zDu6eeysDycv567IF8V9tAPBxi/EdT2eJPtxIL2zx3+i8YUFlGv4pSGloL+W2u0ny3uJ7Nh6766ICPebNqOf/4u4JgzlefzeNnB29DNpMl5fF9//fA2xz8y71+sDmsl1h90YnfAhO11n8WQvzW2760SLsHgWu11q8KIUpZD1h0q8IOw4rb4u/b53Xal3RbsCSeLCUgBA42bUpQZbVjiZyST5YQ4AZJeX5hjwwhcoU0BC4aNCSEg1BQZq2E01N5GzT+v2W3kSEKo8MOJB+C5P10KhXtLoBQ4UqUkBVQ/Tyk3wFrMCK/dHHr7zqdTqu2DkoVoJx6qNvFbGRAJZ9A9n8bYW8ANa+DOw+tB6PrD0PrJRDaBdn3PrD6gy5SATDbA43jlYRquhRSXuW99Kuoqgch8W8gSbCEm3kfYoctY5ReLDdWjy1e6+zwanWKtdY/WdZxIcSJwEHAPnrVq65THhpNS16CgiKCMVaecdW+kRVIrTxNCm9u4C3o5ZxWrzFSa/zYsFGj8HU1NZarCpxrKTVVwjZLhx4cJaiys7S5gpA0Z0m7FiNKhpBU6eBhYHnLh8KndgAhK822VRvxft3MYFqtjsnuRqbAzWVInzd6XNHvRQjBHoOHd9r/7Hdf5S4eQEK7m+XBLz/hmg/eAOD63ffnyE22CBxiH1dOnEi5HeHZr8y8LBNAByCTyjDu9vuYfuUF3HjKQVz+0Et8Nju3PCmFYOSA7ukTH345h7JYhM1HLB/f+O3Xp3PNFU9AaRQcF5nM8sUncznjwgNQXlZjKGIzYoshyzVuL7qBhk45qz8cDgX28j6PB96kgzEWQmwG2FrrVwG01oVyKOsofmw7vGXV1h32CL92TxAt9rd85QnLo52Z1oKQcHGRhDxnU3um2eck+yuCvjJPAodSrYNVON+W94xQIaHl2h60q8Bwg/Ody0TnZqISwmOLjiBkFcQO6XygUxJdCNwFqPrfgDvTaCL3fRFaO2gg68Uotw2W7o5JKPRXKT1k30E1/gZZdQO6/Epo+RuQR62wO3OLO03NaYPM6xDeA2kvX16mqv0JqA4vScknILQpOF8DJlkdq/PzqRcrgdVni9c6O7zGcIqFEAdgvqw9tdZFLMnKIeM2MLLyWOoTn1GXnsxGlaeS0Q5Tll6HKffsGUlhnGNXaJPA4ev8CrC1Iisktna9cqR4IvIKpbUnwpZfb1QTEQ5JHSbfEGVJ5oyzxpNW04Skx10GopbLK7UTg3GCMfMD0gJanHYe3uZEbv36eWY0L2BpuoWFySYAbEuzabyUg4fsyu79N2JkWS4hrifYbdAwPlm6MJiCkLD7oGGcPTGXMHfJWy9y+KjRnfoOK69k/JRPg21XEtQSQYDrPWuHVFfy4IXHsKCumUvHv0DWcfn9sfsSDS/71tzt7NsDisWQmgr+e90pPb6ua658ipw+n4UOKfpWlzJiiyFcfMeJPHXXRIZuPIAzrj26x2P2oodYfZHi/lrrReaUepEQol+RNhsDTUKIp4DhwGvAb7UuFjJbP/BD22GAb1u/5eRhp/N67SsIIblgo19zyzeX0JStNTWI8m0ckFRhbCsduLAaiavAkpIMFpZW2CgsNE0qQgSXsHSoyBtHA0ntEBO2CSoErOWeuMUC3NndN8u8CtX/g+ZrQESMo5iP+K/AGgCxI5ByOR+9ogx0/kpfObr1NnC9wIVaAvU/h+ihnfs2nkpOYaPI/38Zo0ok40dB/ChU+4OQeBTs0VDx12VOS6XegKYzctvlf0PGizj1xfpm2jo7xADhHRHRg4zuiDMTYscjwh1fpHqx0lg9tnits8NrjFMM3AFEgFc9h/FDrfWZq2Lgpe1v80ltbqit+93BgBITNa2ObMn3ra8xvflfBfZRepnNynNyhccNzirL0zo2tALXK9chhaZcDCahltCuTaKIJTS2BWhN0g0jOwSZfVjCLBs6XilohcAVFjNbp1FqC9ocQ4MYHh3I9Pa6YAgBDIyaiOrnLZ+zILUUEEgRRmkTejljk33Zb2ChQfm4bha3zHiFslCUK7c8lMHx4ny5S7bfnZZ0iv/NmUlNrITf7bA38VBn+sSf3nsT11JI11xgRSTCUVtuXuAUF0CA3SHpZXB1BQ9ffGzx9h3w6uSvCzjH85cuQ7qoK+Sf35bc9u+zANj9kO3Z/ZDtu+jUi5VGz+1wtRBict72Pd5yfYBl0QB6eA4b2B3YFpgHPA6cBNzX41mue/jB7DDAtdOvZnbCSBBGZYxbt74Dy7K4fLM7+bjhDV5Z+A8yOoEf69UIdF4RIv8GalcRbJnE0TYOGkukTZBCCxxhE2M4Cf01cRVUkKdFp7GVICQNPUx7IeWexYs7FuvYFphauCt2NLi1RuUBF3N7eXZKlEDpuQXOsNYuuvWvxikN740ouxAhuuA/933OJMK5iyC8J6L8UnTD/xW2UYsg+a/CffELIP3fZV9atFD1R5b8Akp6WLGu6eLC7ZYroJQ01p4AACAASURBVIdOMRQJCNq7I+MmGCEqrunhOL1YIawiW7yu2eE1xinWWncstr7K8EXdlQXbX9X9gfLwVry78GhclWFM/5uY3nx/7h7xqAm2VmR8vrEvjSYcFF6ChwCp0yghjQA932NJQTkOSRUKHK8ILq5wPLF6hV+/CU1BxDgiHZS2sLzMUBeLkISqUBJNlN9s/iv6R2u45ot7+ap5NsPLBnHhRsdz7Ie/JummCUtIu5KScBqlIvQNx9mjX2EUtzmT4LzJD5N0s0gE53z0IE/vdT4Av538DM/MmwbA77f6KceN2oGrd92Xq3fdN+j/wqyvTMjX+7IsIXht7iwIgQqZnaMG9GXTfv0oDYdpy2QCqWSftF8RCfPquV0LpR96x3hm1jYggX+ffjRbDxlccDzeBa+5p9hzn814a6KnSSkEZ1y8P5V91xGZoTUcyyEGX6e1HrOsBsuiAQghlgghBnrRiYEUZjr5mA9M1VrP8vo8A+zMeuwU/5B2GAgcYoCUSjK5aTJ1qbm8VfcS1eF+HDDwJJ5bdCe+gfHqg5JWFlHpeLZZkyGE0ikEGikFSSJYaCw0Ga1pUXOJSouM1lTlVRZt1mkqlQkyWELSs2Bxh4BV5ABE5a3o1FxoORV0CsrONE5p89V5DX21IgmxkztFh3XiERORJQXO92BvAPGjUdks1O+EcRrj0PdjZGgQVD9T2N/t4FRGfgLp/xXui46F8FbQ1MVKWuhAZMUfix5S2VlQ/zPv+vsjB7xTpFVHKbqeJzXK8AAv6JRbx5fV6+3/eqsdq8oWr2t2eI1xin9ISBHpsB1m4vfj8A3vh4tPZfeau3lv6W9wSHoUCKMdbKMCnpvWEEaRyaNIBJFk4SXjiVxugA+BpsTK4GoLDWSESQtJuSGyeYl+/jhg+MNu3iBSpJi4+AWO2/BErtzitGD/BZ9cT8rnHWsISU1GASJLUqX4vGkWO/TNFcWoS+cMqUIHVIvpjYsChxjg6mkvctyoHTp9l2e9+6zJB/Qc3bJYmB1qBvN9ay5au8tgI2Y/5dwzGf/Jp9jSYnhlBc99OZPDt9yMXYYP7TSujxPvn8DM2gZvfvB/9/yHL35/Lradu1V322o4fcpiQYLeViOWT9Lsd1f/nP0O3Irnnp7CCSePZZNNjdOdzjikU1nK8wqK9GIVQtO5Es0Ph2eBE4E/e/8WC5d9DFQJIWq01kuBccDkIu168QPhm+bP+KjJ5CcsSM3lsXmPsk//I/mwYUKuwp3WOEIawlqQyqFJ6xAl0iuC49En/KS7LDZRL1/E93u11jhC06rT2EIiNcREBKuHzOIA6cnozGRkbAeIGUUfpTJQu0WRxl4FhOQjUH5e4SHnO3JlppNoZ7aZScM+5KKoCagfCwMmFY6aWQB0qDpXciWkXyE/2RB7JFKWoPq+ari60X0hPRHcJij7LdIqbuuUUlB/QN6eJajFuyIHvF/YsOo+aMxT7avsUA66G8gBM1BN1wHtyMocb1upBqAUKburGtiLFcLqs8VrnR1eL5ziMQPu5d0FPwMv6jCg9BBamv4JQfKG4OP6XxGWAqHwikCDKywsrYNtASA1EZ0hrUN5SSF53GNvTwjHc3gJ1CKUp5sZIYtCEpNZXCWMOdcUjCfyEyK8pL036ybS5rbzs4GHc8PMm2hJtdHoCvy3cz8JD4864WpFv2ghNWJYSV+GlVQzr70eDRy2wXYAvDQ/v5qPOe/op6+if7SMl/Y9j2ieU5ofDEi4Dn8bdwCuUkxaNJ99NxzFRTuZJBLLsjhlhxwVYfeR3SdLTJ47P3fJ3kyemzaTw7fbvKDdqzedSVsqRdS2CxzmnmLHnUex4865oNjD//mAex8y3LpRI2q479aTlnvMXiwbgtVaNvTPwH+EEL/ELMkdBSCEGAOcqbU+VWvtCiEuASYKs2QzBbh3dU1wfcRe1XvzZp1xggdFBzO5+W3As5EopEzwZt2zQJgSUmhLIIUihCKDjYWp+GmjSeowWkGJzORUKwC8VT0waVpZIOxRJRSQRmEjcdCkdYYoYWRXtIWiqIPG41E1b0LySWj/Vzf8TAnWoE57Rezn6OQz5rhQiNjB3vQ7yts1msp7sdORFZeYXW6xKpgLoO8z0HS+uerya5DSlLCWoWEQ8qgO4a26v0RVTJe5c8lqGdkKBnyNctpWuKiHrMwVKVFKQd04IwkHqPLrkPF1o5LpmoTVaIvXOju8XjjFJeFh7D/8CwBq299ncu3pgbyagV9NyPB7tedculojhCkz6mqBFkaNQgIRkfX4bH7UWKOFCGyjJRS2p0mc1TYqcHIFvkS9lFAuMmQUZKWNo21c7T0chCCtBZbHZ/YjyJ81f8Lkhq9IqiQZDRFLknI9OoGAX298Ii8smsKSdCPHDd2HYSWFsma2tBi/62m8W/s1JaEoO/UdAcAvRu7CPd+8Z4YJxAkFS1ItXDvtBcbWjOLCSU9h2QLXyX1fF2+zG1JKbt3voFXyWw3tW8XspY0Fq5rbDR1ctG1pdNXpSv7z4feCz9/OWsp7k75lt51+0JXk9ROrySnWWtcD+xTZPxk4NW/7VaAHXkIvVgVO2PBETtjwRACu+uLXZLTRe5RaEbcKaQppQkS1oZ0JaWywwiIuM0HGbkqHsZXGlg4OxpJLICqyfhYzrUogEYSEJiY0UoiATxzrsIq4XGi9A1JPdH287GZI3A6yGlH5l06HRXhrqH4Wsp9DaCuE7a2g2TuC80Hn8ZL3oMrOgoZfgjO10+GgCl3NCytyNR0GK6b+03XVvlVW5S75UOAQA9ByFfQ6xT8MVoMtXhvt8HrhFOdjcu2vAAK6Qb5AjfZW56TWaLSnL2EMgYlD+DI+hmBhCYeo11IIUEqTERabxo9kRuLpQHheigwJHcYCFApfj9g/ty3AFYKwt9SmNcRkX44ZeDwPzr07V4lJg1ZJFIZjbEmBEJq4yKCUwFGCPfuPYc/+OfrPi4ve48WF77Fx2VDOGnU0UkoiVoh9BhZGXqvjccaP/X+cNekRko5bII309JxPeXzWZwBYYQ2WYmiohv02HMXeG6xax3HCacey90330prKooHDt96MYdXLJ/OzuvHUY5O4+1ZTCGzQkEoemHDuSo03a/oCku1pNt9hxKqY3pqF3ipKvQDanGaWZBZSSEPzobG8Qh1pbRPCIa0klpdv52d5gLmd2gjhKg3SOMRCQFJZlIos/SJjSDrv4fpBDq2IWJDWirBnV3N5HbpgO0DZ76D1LqC+cP+yHGLiyJKfQcnPzPWpFLrhPFDzoeQsZMzQMIU9DOxhBT1l9XhU43mQfqnzsHVHgPouvzVYoyF6SlHd4hWFlFFUxa3QfL63R0DfZ1fJ2MvEStoHVbuvV00QKL0cWXrSio+lMpCdBNZGSHsdrDraa4uLYr1zivOTJnxag7k1dBDB9W2i1HiMYoGFxiHnSUtMxTvlURtM5FcQ1S7zU/8DdIEzG5EuWptKS65WgXSbEBqlO3PakqqeZxbcRpkNrpakXY97LCAqANIklYmUSgHSUkQ6lON8t3Yqd3zzOADftc+nPtPEH7boOpF8p37DGdt/BK8vnoHjmmsVaLBcwhY4jkRpiZSwVDXx6OwpjP/uI24YcxCHDF+xl7z6RDtj77+XtOsSlhZvnvRLPr78nBUaqyf4fmkTp904gab2JIfsshmXH2ceTqcctxv3PWLoEyOGVS9XlNh3iAEWzm/iqccm8fNjdlpGj67xpzPu570XzQvIkJH9uPeNy7vpsRbBF53txXqPhK+lnr/PtSmxHITWgWKiv9IWk9mgeVpbRHx9YgSOtonpNMLKicq42LRoSTj7GeHApguyCNq1l96lNRUi5wxDEYcYoPVPy3+BsQ6JxPVHgOtVsWs+C2U9jQxv3rmfP4+KP6NrX6VTkl+BQwygDJWi/TJ0ohT6vbnCldlU253QdovZsHdBVo+H2E9XaKyene8eaLsDRAyq7kSGt4f4CZD4l6muB+aFpMfjPZBziAHaroMVdIqVaoDaPfFVR1TZVciSnqkjrRXotcVdYr1ziquju1GXyi2VGzdSefdH5+Uh30TKDrrFfn0OJ7CnOf5vVrUhsE0umvbYbZ7zbQOWyOJgSpMqLYhb0Oz6C3+GvqC1MAZam3MLkTuH1mBLsJSF63PshALhcuXnf+DS0b+m1C7lvfrPCq7li+ZZPDf/HW779inj0Guj+Xn80H04ddSBAOxYPZx3ar/Gj1jnvyTYtiKTNcSTtMoG0eSLPn6W0kiUcYM2Xo5fwuC4JyeQdo3hzyiXY554nDdPOrWbXiuOX/7tceqajfzqE29/zg6bDGXf7TfmF8fswtGHbU97MkPfqu6jLR9NncO9j77DNptv0OnY0tqWIj16Bt8hBpj/XS0zP53LJtsMW0aPtQurkVPcizUY/aJ+5C3PpgJpJbCEJCbyncHCeyarLK98vSG6oSElwpTpTMAlBhMsaFGaapnTg7e84wLjbi5WbUSxiQkbB5eQtojIUECt65lcWx86Jb0lb0eFhyOiPzN2vCMHOD0R1XAe8H3eTguqPzZUBBEDazC4RXR8O8GrCKob0EvGIAZ80YM+ReA7xADOB6j0JGRkxV7uu4NyvoO2v5kNnYKGE2HAF0aho9/bKGcJyAqk7N7BV81/hOwXIFdhsaXWv1Mgw9f2V1iXnGJ6bXFXWNmi8Gsddhz4D/qEdw22lWf0JMJbsjOyCr4Em0HOkAqR4/ea4hxZr58/mkJITQiHsHCIyixhmSUks0F9PCkhLDVR4RKVpgxIRLjYOISDzGEDv7CH0Ul2gz8Llwd3+gcSF9srgSoEfJ+cx2XTfkeb08bOfQurEW1cMpTbvn3SXJ/A001WPDJvYtDmuOE789stDqRPuMTEyDs9E1zvYVSI3378XMeGPUJTOlWw3ZLpqAe6atHcVni+6XOXBJ+j0XCPHOJ3J33NxVc/wYxvl/DYfydj98tlcEsp+MVpe66y+ZZWxFfZWGsEtO7ZXy/Wedywxd34BDZf190SErBwtAxuBYHC0SJ3ewQWUZrgAQqFTaNbQkZJo/OuNRklSSubejdCs4rS5MZoUWEycstAM15hqt3V6xSOVmRxg5ySniMMFKlJ0HwxuvU689nq8GKbnUGhQwzgQuMRgIlYiz7/huhhLN9jOoNKfbQc7ZcBZ86qGacYsl932JEp2JJ2/545xEt+AslHwZkGmRco+K5Cu6/4/GR5hx3roApGry0uivXOKQbYefA91ET3ytvjOasCIwPkKQqHhEYKU5jDJLsp8sO+AlOSOCwcLCwTBQZstKE0eM6nhSYqFMNKtvO4zD53zbSxhYslHMJSG4cZpyAyHBKuV+2O4C8sNRd+ekyuIEgeUm6aj+un8NSCCVRHNf0j5exdM4alab98Z+5B1LH7k/Pe59ZvnsSxGugTS9MnXBIc26xyIJZlEgSl1AS6bEDUXjHt4Mt336Ng+ze7FhoyRyn+8s7bXPHaq9QlVr7A1j7bbRR8FgKO3H35aR93Plio19kq4S+3n8BZF+7Hs29cRiy24gb0lMsPCV5Exh2+PYOHL18VwjUbPTTC66EhXh9RGi7lxq3vJiJCBQ8iIcDBJqVtMlrgapuEGyGrLRzMn1mFw1slM3Y2o22aVRUZLUkTIU2YFCGkkMbSCUFChymNHw90vs3acUlqp2NgugdYDFaxss0aEo+jWu8CVQeUgBgJFbdA5rXiQ6lc1TpddwSkngFU53LLVucqorljxYsxdQuZn8MQgmhhgpvKfIlquhTVPn7Fxs9HZE9MjRgPdtdUkmVCd4ikW5tB6e+gajyy70rI3JacDdaG3kYIKu9Y8bHWSPTa4q6w3tEnALLZLInsjECBIketETmdYT9irH1FCVMKWnvKDCqvypJxfFMoLRGeAoUQviy5T45T/HzY9dzy1X74FGKtlTmfhrjM4Hg3YEZaKOWSv6xYHiqjJduai9x6/UpEhhR2UMHOzFzxzzkPB9sOKU4afhGnfHQ1FsorTW28ehvoY+cyjW/+OpdM4aLJ6HrCls3I0n78Z88zGf30VeZ6LY2UGtcFgcXje3augDS3tZHHv/uUmlgJx4/anrDVmZ5y6CabsXGfap79egYHb7QJm/UrVMv4yQP3M6/ZaCA/OX06n551dqE8HEbGR8qevd9d98sD2XHToXwzfynHjNuWwTUVPeqXjxFDq/l+YWOwbUnBtmOGs+2Y7iXnusNRZ47jqDPHrfQ4ayQ0q1OnuBdrAWY0zyDlWoCFlG4HmrFAIVFagcjR0FwhySphKGR5HqwQgoxWuNrO5YWgSSojnxmVWSw081onsMOAz5m/ZEss77nvYkptZNFYJNACbCSlRLA62Zb89GwP7lNdXGEE2m/ObepaCO3XRVug3BT/UO1Pg16c2+98nvscvxbUh7kSz/mQGyFDG3XarVMvoTOfIaJ7I8I7Fj217PcSKjEBVC3ETkPm2WuV/Roafo7hqjyNynyKrLq5oL9S5knaE1ssZRzV7y1ou9coXcS7KC7SLTr8FuFtkKU9rMa3zPnZUPNK9w3XVvTa4i6xXjrFb83fHZcWBEaCzSS6+S5yXm6zNuWctZBkNZg4sMZ3h7u6pQTaSKkJw9tRaBSS+74eS0yaJT0X6UV5TUKeQCC08Z8juGSFScST3nhZtw4I5zjKHiwL4trBVYKUNg8XpVP4Chc+bv7mLjRZQpbwrte7Tg3b9u2asyolhKRiXmoxO798GXv134w3lxh+3NZVg3l87+L83+ZMkkNf/hdt2TRhy2Za/SJu3vXQ4PiU2vmUhCJsWlXD6Jp+jK4pVhKdwCEGyLguk77/nj2HG+dz6sJFHPvIf3CUojoe5/UzTiYeLh6lveftj/hqUS2XH7gXh+1WTGS/5/jTpYdy2C/vor6hHSkEd11/3EqNtz6hl8fWCx/ZbJa7Zt2OzytOqjClwiyj52hbkiym8pzjSELCJUYKbVu4WuFgYws3MMZOXg6HEKC0JCXMKlZa2YRxkNlZvDV/b0pEhL4y7bXD5IMAWa2xhcBB0U6GcqJB1kluVj1dZO1Ygr4V6nfrunnEizhnl1G7IHEFEAPKzHgA5bci48WT4lTiSWi5GkiaKnp9xiPC25pjqg2yUyG0NVKWI+NHdXHOxyl44qULI92q6TJIPWk+x05CVhRPEFZOPbT8CUIjkWXnQPmlXV9nT1D5L69anwYxFFnx+5Ubbz1Cry0ujvXCKf6i9kJqE0a7ccOKs3ApTIQKCY2jLSQxXNpzqR/CV6BQhIVE4eJo31k1rUw8WSOxTATY078UXlKer3ARJOyhCUuHrLaCangAlta4XiMhYK/qQ3in7lmPxwwhFMLK0O6G8CvuudolpF2yQhCyLEK4aA1ZbRFC4WhJStmA5Nu2OcRDFknHVz72rlJAmZ3jrVaFSmjMtgXz6KiM8WXb13x1eNc16Zcm2zjotbtozibRGF3RlOvwzuJZtKTTbD3hJnTe82V0eT+mN+SkjiYdcToDKnISbGHLIuPmkm42rq4OPp/3zPM4XnSiLpHg+jfe4Zr9O0kicsAt/2Jug3k4vfTlN7xx0akMqCzr8hp6gmfu+9VK9V9v0WuI11u0ZxNc9NklpFSasAhx0tATvCM5G5NyJfGQICJCpHUiL+FYo4SFg6CVOK5Ke3rFklYVw8JFaUFEurS4MSqsZN6t5o+vcbCN9dMOmggoKJdZs3LmtcmSezBmcVGxcyB52yr6FiToxmUc984c/wOkJiyjXRJKLkaWndFlC9V2L7TdRK4cFUAWMh8ZpYbMi3mtBYoY4FPUypED8hzz8LZGQzi4jNyKnnLrA4fYTO0BVNklnarRKace6nYxGxlQiQnI/m8t4xq7h4zuBgNmrtQY6y16bXFRrPOc4rbMd4FDDDCn+U7ySfO+ubREhgNHfMBO/e4pyGD22Q9CaCwBpfYAhPA4w8JoGVuAFC6V1hCk8AyQJ/Xjax8HrAdhNDnzyQ54VfMskSUssoSEw6YVOyNFfsTEuOAllkOJlSEsspRYirCtiFsKgetx8WQwZ1soIsJhz6qd8ZU1wpby5mjOXROu5OQRuQhuPAQWLlIoLFxsWRghUd0Q7g55/W6asknzsiA0UrpEpMWO/YayxzN/z3OITbR6ekNhlaSxT/2zYPvxo4+mX0kJ5ZEIf953XwaW5ZzZrFs4t2S2MEnRh+8Q+7j6+deXeQ29+IGgMSG5nvz1Yp3DX2b+lZQyibQZneWphZ11bx1C9A1twrVbjafS7kegRxxkQAi0thCUkFZm5czRkqQOkyZEqwqRJURaRYKiSb5efD5cTNlogSDrJfVBjkbZ6EKdC20qDla0QLZtpRA6rOtjpReYZXtAdrHiVQDV1vUht8koJnilrvMmAOHtOjjEeG3yczZaUKmcvJmMHQSxE0GUgDUC+j6e17WY3S2i99V6fYdTFqua14vVgl5b3CXWeac4mS0k4msNfe1dyTcUPnliZt2tZDqV2MzBFmFS7iJyCWY5JYq4rGBwfBcvJzr3Zu6XkSaIm7peP41nshFCG6UK4QZqEy8suCpPDcM4sqYWnqTCGmyiJ34YGYgUOK85rnPYUnzS+iZjK3YgLLLErQxV4RTHD9mPx3e+gQd2vpqwzC0YtGWTWBbYXtKfLc35bekQshwidu48l33yb3Z/+Q+c/H6u3n1zOpmbhYDqWJxzthjLzbscStJ1uvxufTi60JhuPWAgH55+Bp+edTZHb1GYbHLVfjnubdiyuHSvYskunbFR/2LVmtZ8uK7bfaM1Gr3JHeszWjKFK3Stbhta20HgwLdw3yVmoZSi1TEOtH87OMo4uEpBn/BQsp6l9fXlfeLazwb8lTbXJqUskiqEo430ZRAv1pBStreKBmksktoirSUtKswCFaFVGbZyUieoTbxvNCm0JqMcksrBUS7IoXmpxj2E+xmG2uZBDDTUhwFfI0vP6qZzB0fZNd+nyjajloxFLd4G1fao92V9U6T7YYiqvyPCO/RwsnMKtmTFFcj+U5E1LyGtnA2V9gAI5QpGER5XXDkitEkPz7vmQ/Xa4nUW67xT3Ce6B6LAmAganTe8z4UmbU7rP/i8rqtiCdpj+GpCHcyg78jOapuA7R0PoQIt41ztOmO2jeyaJiQcoiJLSLhI4UvDGUe73WkkJlOEhIMtFLZwiVoOFZZgaElHDrAOsrHzZeXy8Xn7FE/bExDwVsPL3Pbdnby99P2CdmeMzJVrFgJ27DOKsO0gpZlXVme59NN/cdkn/+a1JZ+TUlm+aP6eg183ZUx361dYhe0P2x3A2ZvvRsSyuXGXgxDBHWfm2KdDqeYztyyeBNIRd02exJmvPotborhq/3FMu+gcakqLy6ldfuBewef+ZSVcuG/PnOc1BZmMy7hf3sZuv7iFnY+/kWffnPZjT2nF0WuI11sctUGhmkFapUkpjVvwk5tM59OnnEJrNkFWCRwtAj14pSGDTZgYGTdEczZacLtoLVBESROmRZVQ75bRrqJktYXrOcdpZeMQolmV0uxGaHPDLHArWeBUkMGUsE9j4SpIa8ni1ETmZtM0qhRNOkOLSrNUJWgJH+fPuOdQsyBfdlMvgsQTqIYzUG7HgEx14aboUFAo82/zb/2OJoGPBLT9EZX6EOztKHy8h5B9bkBEfHWfjgoVnZ1YGd2zJ1eEWryrx4EuhepXkH3uLtpOlp4GIk/XveTiHo2/JkElnkYt3hiWjkYt3hrlZrrvtKai1xYXhVhly0I/AsaMGaMnT15GQoIH180wu/l2QlYFXzfcGOzPV53woTFJmSoo5OGTH4QpPOp9XSZb2Q7aCDS+rITRjTAGadzg+5m48LekVGNwHqXN8p0Z2kQ/slhoLbxSHKav4QdLHM9Q++eydAkNrgv+GEBSCRN18TQ6FSHIYy23uZFgDJNtnUu2O3LIoRw66EA+bphGWqUps/rw/MIPGVUymH/OeZ6skuR/R8PiNcxuaSOtCiO/H//UaHLe8uUbfFQ3h+OGj2HcoE2I27mXki+XLub3k1/moA1Hc/Jo4wDf9sm7PDlrOldsvxf7De++AMi8ujr2eOyBgn1zzrmEyQsX8Mi0zxjVpy+nbz+GUBG1i7URV9/9Ii+8Mz3YtqTgvYcu+tHmI4SYorUe033LQlREB+hdh/y/HrV96bu/rdA5evHjoKe2+LvW2bxb9x616VqmNX8Z7LeEi53nw/nPpbiVybN8Oa343Jamj91GSJr2jha42vKoba4nsamJWGFO3+ghnp69f4HOvI1D2NN5B00YhworCWgigTSmOU8/6QYSmFprXKC/KM9RzERP1I2XnaJNzecIGiH9DtjD0OlPwJ0L6c9Ad47+ygFfGyctH/ZOyOqHUG4DNF0CIgxlV4A1uEAZQrXcAZl3oexvyIgpfKHqjjHjVj/W7ZUAqMU7UJhMGEH0n4puvx+cmYjYkYjIzj0aa22AWjyagiqDkYOQVTf9aPPptcWrHutFop1lhRnVx7yVft1wM4WkBihk/WosIQzNQfu3vwzKPftlQC0A7eAAlv9G7smk2YCLQgjJGwtPxVV56hZaeOf3w7YE5zXpb1YwK0+N03OKCfYj2okSM0kgSFwgIgWCLJoShBBEqKY+uwjL8+LjMk1CGcdY5TnEAC8vnsiCRB0f1k8FYEC0hr9sfRk3zTCJHpZQuIHkm+CiTY7gxukvMrN1YTBGTOaWBC/YfG8u+ugxLvv0CfgUDt9gW67e1nDpNq8ZwJM/PbHg9zlvu7Gct10uevvfWdO5/6uP2WPQCC7atrMA+8VvvOLNxOcbaqYvWsiJTz9J0nGIWjZL2tu4eu/OSXdd4YuFS3h31lz223QUI6r79Ljf6kAiWRiNWGtpXj6PrRfrLUaWDWdk2XDeXfpenlMsUNpCa59aJgJpyzYnYhxcoQJbZnTcc9qUDU4pIZElJjNIYQVqEhobLTQOZrn7H9/8gj6WX2uUQB0oZwpNlVGtoV1FiFoOQhH24AAAIABJREFUIMgoSRaLNjKUSTcw2wqo0wlqCGEVqYZq6A4SU5gil8fRNTQkH0O33276aKD8cmTZGajFmxVp30Vxi5jJEZFWH1TFX6DuJ1C/D2Ch+vwHGTY0NFl+DnBOQdd8Z1i5LrReBs73UH4ZMlxM072jukYa3XoTJB4GUujUK9D3CUSoZ9VOlVKQegp0CmLHBBzrNQcdfj/d/uNMY2XRa4u7xDpPn+iI7QbcH3wufKv36Q2iwGW0gmQ3Qcc4gCRffjzH40WQF1FwTBTEiwGDa4p7+DQH7TvAirBUhHG8sT3esVREPLpF/pyHxIfSzx6ILSQ2RjouKiUj4kMYGRtFQs3Dliow4CGpGBEdSolVQkza2MIJtDPCIsx7dZNJqwxplWFxaim1qXr26b+dmYsAG0VIwD/HnM+2fUby8NhziEmwLQdburw07rfBN1GXauXVxTkNzae/n0pGdc8nBnj8m884/91n+bR+Ebd9/h6nTJzApEXzGPXAX9nw/hs46ZUJbFBe7v1iGr+23py2toCCknIdPpzfsVpU13jqsy854r5HufmN9/jpXeP5xzuTmDD1cyZM/bz7zqsBl522X3BtAMcduP2POJuVgQbl9uyvF+s0xtbsRonMqd4oIKMA8ivX+ZkYAqUlboESTuGLvYtNUuUqSwphEvMcZR5xWSxSbpYGt5Skssm4khYnwlKnzBsfzxZr6lUpSaKktYWjBBltVvGWuiHDNfaixArIyOG0MRzXGonAFBuqdxMs1VHSof1Ja01WZzon6skhQJHcBrcWdBZ0EkhCwuMIy+GF7ewtkAM8GlU8l9OBGIEsyaOptF5FUAYaF5ov6XzOrlC/tyke4kyBhiNRmdmo+jNQizdGLR6NSr1XvF/mQ8CrHCokOMtRdrr+IGi5HFqvhtodUelPUG13ojLTu++7OhA/LW9DQsX1XTZds9Fri7vCeucU943tSHl4W/y0jhwHFzq9BeYts+XzdP3/SpHjCRePAPg50y62cE1lOmEKdoRxCeFgCxN5sLxz2UITI5OXa20q2oW9Ok7+D9aQmUGaOVyw0W0MiQ3DkhqFw/eJr/g2Ma3AfffVM07c4Fj2G7AnQiQJC0VMZrFxaHWWELdzkVeBoDJcznZ9NuaskYdSbscZWtKPp8b+kY0rzDLb5Z+OR1kOljSFPI5457rgfDmFCoUQ5u/09++nIxyluGbqy+z74p1cM/VlHKW498tJBW1eX/Ad//fSY0FhkzcXzGZYTWWnsbYZMBAwN3TMtjlgVGcB+65wx1sfBp81cOOb73PF86/xu+dfY9cbi/PjVicqSmO8M/58rjvvYJ66+VTOPa5nXL81Dn50ojfjuRfA3TvcDghcJXCUhaNDJN2ubgOBq/KjsTmbq7RAa4nrhxo8p1rh0dQQOErQpsI0Z8PUZiuodStIqChpIizMVNDsxmhyYrjYuErSrsLMdvpR78Zo1iU06hKadQlLnDApDVkNjSrE0uxcvs18x1eZFKriURarLGmlcFUd2dQEoK1TMMXVCtnvdRBFAgXJewB/fwRCXoS477Ngbw+UQ/RYZHVesZBEnjyknoVKvJo3YAcVCHc2KvlSp9NqZxaq/hhU3cHotOfsqsWFjRpPhuwb/kDQdDLQgefMcIgegNFR9tZiQz1beVcqBe63eXvaoPEYaLsFGg5Dtf34tliWXwzVr0PFbVAzDWmtWauKPUavLe4Sa9raxGrBDgMf4K1526C0eQuy0TgFzDUDXzPCJMVpstpPm/OdU4EWOVkf01d2GiUXg/aKhXh0DcuLcw6O7crcxPv4S4cas6wnguQ7TGRXaY/HLILZ3TvrTBytiAjDE07n/aS+GrF/LXfM+z0S4zwKk89CyNJeckobY6p2IuGmOH7Y4cQsszR3xNA9OWJoZyfs/foZBdstbppdX/ktGqgJl7NHv414Z+nM4FxTm+YxYc5HHLVhLpHu399N4T+zp5JyHRbPbmHD0j4MKqng25YGivwcAabVL+aSnXfjlo/fRwrJxTvtxmdLF/LvI4/m9VmzGFpZwaGbLKMMagf0Ky1hQXNhZrx/+vpEkoXNzQyqWP7Kd6sSlmUxbqeeLUGu0ViLcxh6sepx7AbHMn6uoWlprRGEyWonoEqA0YpHGCpb0rFJYFFqG65xVgkQxuZFrSxtTpiIcE1/LwE6ozyLrUFJm6w2lLSMtimRGbIiREpppAhhiRhJvyAGgiRRj8ZmqBXNOk5TOkKplS6gUqTd2Xy59HD8hOxKrZDecqFCYSGDaHFGO6SXHExcd6QeeLA2BWmBvRGizCR+S8uC6n/37EttuQTV4kWHYydhHvN5Dnjz+RAr1PbVjaeBOx/Q6MZfQb93O4+r6zrtkgNeQC3ZH/RcEIOg5BwIDUFUXIt2ZiOi+yHsoT2bN2GWyblu+zuUntnDsX44SHsI2EN+7GmsPHptcVGsd05xxm1g8vxDjBsscolnEqMVLAInNgc/zSzsJXho8ljJ3jKfz1NTuEYr2HerhAgS8HIsOO2n5gGwOPk2Fho336EtCC5obASWdL3lQK/OnQYXN8dz1n5kWoJwCeEGkRJ/uEGRwTRlO4vHW9j8ZnTPC1JUheM0ZJrM8qYWBZX2lmZa2LpKdrgG+NMXz+FqzTHDdwJgTlsDKU+mLeU6zGlr4PY9D2Xrx24J7GLEsrCETcLJZWyft82ubF0ziHPG7MKfJ73FrVPfRwCDy8p5/ucnFi0nvSzcfcxh7H/n/TQmU0WPl8diRff3YgXQa4h74eH5hW/w4BwT8fQpahpN1pVkhU9XM/dLSGYhz662OqYIhyUUIc+BTrk2UlgkvValMoktXaSQXhEQkwsS2H2MHbcAVwuSuoTpyTTVVppInsOrtWfGtSCrbTI6QtaRlNht+KZGor125hralSAmFCVegrbyFCcUGlcrtDMNrJh56ngBEO0HQqL7LrMoR/dI5n18wJRQTvwr77hGLd4Oat5GWp5ij7uEAmdUNUD0MEOf8BHaE7L5UWgTOJH9X0arNnTdgdB+JWiNLrsEWXbucs1aSokqv9bQJ4oi0sX+XqwQem1xUax39IlJ8/cho2u9LePkSmFjCR2YXL+0Mt6/nd3k/CQvb9vjHkuM/rAsEiv2WbA+t1jm0TKswIHU5HxJj1UnciPEhEOYDF29TY+tOYQSGUKisD2qhvToE1pr5iYmIzyt5FwU2Ui+3TTjLz34BmFK/QxanQZCUhGWLmHpYMlCkfhZbUvYtHxgp77Xf/l88PnI4dsQt0KU2mHiVogjh29DRTjKwz85hg3LK9mksoYXDjqFaceey84DNmCD0goe2PcItq4ZFIzx6FefkXCytDtZFrS2MLOha53prlAZjzLpkl8xekBNJ32lQ7ccTWlPhPR70QP4ZNEe/PVincastu+5b/YTAS0KzM8+JDLEU/6R+KWRNBJXWV6Scj6XWBhL2+l2MRzhVhUlqaIFXGSfOqw0ZJRF0g2RcGxaVJysNsltTW48mE9GmZU5n+Oc1RYuFklK+MbpT5sbMsEJXfgoVVhUVD/DIpWhXmVpVFky2g2oZW0qyyKnFe3psmttng2tKkVL642kE//t0feolhzQfaOSM+lk2GiDxpNym/FjQcRAxCE0GqyhyMobIHoMyAHGQa66HSrvB7kB2GOg+pNc/8zHoFtBJzBc6PE9mn9HyPiR0OdF6JS4KKFPZwpeL1YUvba4K6x3kWKl2wPH12dbiXzdSG+pLEdQyHf1vHW84LP2IsudE/BkEB8wXDc/OuybTilAaXPEwfK4wwrXO5ktXJJaAnYerScX7UBnsaTNkOjWzEmYhIuRpWP46aBT+LTxXSxtqhPZOhe5FkJgWVAqsyQ9Y+8qgRYChWJG23T+8tW1bFW5Hfv034ewLO4M3j/bVEPyIykSCEmN1gpXG2N2waYHs0PfUZz14Xjeq/u26DijK/vz4gFn8kXjIraoGsiguKEojB20IW8eVrhM9thPjy06xgZlFXxVvxSFRqHpX1Jcq7gn+O9pJ3TfqBcrDo2pvNCL9R4f1n8KGAuaVRIpFEpLvk0sQSCwhPBUJ/AkK0PYvjhlnrk1hTgswtJovevguIm8JtwwCTeMQFNltaOkhY0i7RXQyGizxieVpkRmiEgHV1vUOqVY2iVDCIHLwFAzEp+jbMYHzXyniqGhBiJyAyTfo0kDkqE1jxOObI8C0v4TRCtiCJJakfFWHWvdBBVWCK01DhpXKVzacRvOJpn+lmh0W6KxXJGiTtCzuvmmI0irElXzLizdgwI5MZWjQ4iyyyG6H+h2CO+K8ATlZeXVhcNFd4PoxM6nsYaA9se2TdW7FYQMj4QBX3XfsBcrjl5b3CXWO6fYllU4qtHwezsck4HTqwN6RKFsm/k3xywGhEblvU2ZiCyBpJBfxANySR/gUTaEGc/VLsJzo628QEgcRUL7bnlhJOLQwb///+2deZwcVbX4v6equ2fNzCSZBEISSAJJZF8SWVUEiaICIo/3wAfigiKKPzfckJ/4lMcTkceioiKLKAiiIojwfg+QRUT2JWFNSAhLAiGTbfalu6rO74+61V09C5mEZDLL+X4+Pd1VdevWvTXdp0+fexZ2qT0I3++ruH5hzgVc8MJp8VmiTlj1/lcnsypdUBWWtr/I4vZl3LbqNi7d51Iy/aTE2Xf8bBa3vVY8J5431Gey1OUmcHjj7nztySuJUPas3wkPKVpIZtaUJ6Tfobq+qAxvKoVCAT8j1FRmmFZVz7cPfC+TqzdfKTaGgDFoeTD6cuik/fnjyjjgK3JBdIkLAeLHxTo0Ni5knegL1AeXdziRqUkO9SD08SWkOlOIfYcB1E+5ZUB7VEmVFIretSIlN7iQ2LLsS6dztVC6i0WfMqwoNLJTdj1BFOdALinmHvN2uIPa3M79zrOm8sN0dN8ep3lD6VKXEFNKBpfIyfhCFNGRCozzOi6ks1Oorv4cDeO/N8CdzBGnfOuFNye2+lLn8hh7UHEs9KQC9GpLmShEBAZd6a4vWlgCUg9aDRXzkfpzN7svY4gwWdwvY8594sCp/6AuNw9S+YAT4vyYpJLDx8e91COlQsbnQOymkHKZSARm2pJacslIK9Dxc84FhFRJBZk4/hmISz5XS0SFlMpDg5KTGvJRM290958yrD7byHl7/Zlzd/8jddntyEiSI7m0dJiViD3q9qEhFT2bVOAD6Aw7WdK2pN/+T935KOaOm178TCU/OkNgVfebXPPavUROuD/T8iqfm30Qp8w8mLN2P4pbDvtyv31uDrOvu5in179JW5jnhfY1HDp95sZPMrYhCmE0uIcxqplavR1nveN0JucmOjlScomguC2EmnZE8wg0Q3eUpTPM0RHmCFzBIiX29+0McnSGWbqLxYpKZuW8xmWfO115Z1V18R7xQxHawxw1Mp2mQh0bCjVsKFQVx/FaYTxNYZ1L0Rb7GM+oPY6l7S/QWujfbWuHxiuYPe0Ndmi8AXVSHErfAl0oLZFPRd0P6OmVKSLZ6nwrV4TG2+lr8PAgehHChRDeX+qt588w/lqoPAkm3IRXfRRbgqj9Gmj9GuhqYD0EqxGvd8U8Y3hhsnggxpyl2Pdz7LXdb3hgRXky9ChlExaSeF1XZKNIyXLc20OrqAhruWVZJPHLSVwo/DiwoniluKUvFQR0uoCOUrxwRIiIR1YgowGqEEjIP5oudZXrYnV73/HHc8jkU7n3zSt4vesFdqs/nH3rj+aYKScxuXIGjZXTuP3163lk/X2owILtjuM9k47k4bUPcvUrl8fj6PXDcXLF5AHv42Xz44pqf135IP9c+yxTqyZx08p03srSHfrn+sVce9BXB+xrIPa76SJaCnHw2/f2XcApc0uWjP58h//x+su8e6opxsMWpehDaRj7T9yTVV3ruXz5H8kIqR/ZsZwNo7gmZxjE2X+SinclF+GkymjsaqHqgcTh0gD5yCOXVJtD6IkETyPEE1oLPlW+4nvlsrwnyvGGridxVVP1aS1UIAI1Xp6sF7E+rCO2WGdZte4B8txPhsvI+hG+5PjkrMuJtIcHVv8UgHdt90Uq/F2Rul8zq+ZdhOFamjacQU/wIpnMZCY3XkcuM52w+YdQzHxRwvP6pqAsHsvsBNs/H5cbbvsOaACFp9BoVfxdlcpiBOBVHAAVB2zKv4mo+15oTgL/KqDxKbxMSnVo/0n5CeGiTerf2AaYLB6QMacUAzyz+uSUz3CiCEu5k4JAVuPKdFFRGU6U23I/Y0n99QRCLanNHrELQ0CIqIdPhIorwKzqrLNKQbuh6Ptb+oIo830WJ+C0y2XMiL8WQjye2vAnuvMRi9puRVHW9LzCHauudso+zKk9gBNnnM2Hp/57ceS3vX4jdzXdQkY8AvWd8MzgIxw95WgmVU7a6L08etrBHD3tYB5Z+0IvpbgUxre8/U1WdzezXeXAwr03337ktqJCDPD9p+4qU4qnj+vb1+zxIzRn5DDm69ffzuI31vDp98zjuP33fPsdjsG8l8bA/HL5nwHPpbuMbb5xJodS5c1IhUAjchoVrQ8ZT0sFklKhzAX1yDqJGeDTHQi+irPQ+uSjOAi5wo8IQshEITUuvVs+8uiOcjRkusr8lgP1QD0KEpLRyMlnj0A95y8sFMhAFICX57rlX8Knk44oIEPEm92fJ9SSi8O/73Qd07cvBdKFYcitL3+InnAce+Q6qZTYEBK7iUxgYuMfNnofPT8HDRcCEK05GvSN4r1KUsEViFi76gimTfnbJv2PaE5nJeqB5o+Xp4fzGiFqT49m0/o3NkqUXwKt3wAqYfyv8PzBf5cO3KnJ4v4Yk0pxT7AqvViXUoZ72YDFKZ6qxfA7dQWf+54bWygU56ssxT9FBRZiFwOPuIIdgnOK6G13Tg1BwNeoGODRwM408Urp13/qff102y0Urdmad69iv7gX2+OiGGEY8l8vfJ7WYIP70vHIehFZIn6w+8+pz23esteONZOLg/Fc+en0vfzUQ5fyP4fFfnFPrXuVzz7yawpRyCETd+HnB32iT3+vdTS/5fWqs1mOmL4zf1vxEgDv2mEntt9M32Sjf4696LcsXb0OgO/e9DeqK3Icuffct9ep+bEZfSiXf5HGwb/lLhU+BWeQAAhCqPQCEMiHfmzE8EKEDPkwzroTqJDzwvKy9iqo+IRaACLaowrawyTVV0QWJfTAT+l1oXpkPOiMciixu1x3mKHaz8Ry1nUdqE+WiO6o3eW99wnwCYKQmlQAy+2vf5uTdr6W5W3/4I43/gMIqJY8lZ7H0/kpZKWW43a+d7Pv5gr/IKYEi/FVCVQpEBKibIh6gOfo6LyLmuoFAKxc+0Vau24BfKZNvJI6t7+cXhbFqNcq3fjbYd0+kASsT/jjZo/d6EsUtsP6o0s71hwM22+BCn8mi/tl2CjFInIu8BHiT2AT8ElVfWNrXGtO4495tinONFB6W/ReSihXjouZfrVcdS7PKuFyHYv001uS0SJeHEwEqa9QQFwBEUA1pSSXMlx4hIBPK8uI/229MmFoJh5JMkwtV7YDhe8+89FiaiERD089fClljGjOr6O10MYlSy+gJWgBfHKS4+fzfrXRe3rKw//pCoGAJx49YfkXXVdYspR85uGrCdzSzT/XLetT1APggv2P4tDbfl7c3rNhu7Lj33nwf/n7quWMr6rgd+8/kd0mlB833j7LnEKccP1DC9+eUqxqEc/DnKGUwwCTsg2sKZR+AHcHsTLpS4TvlZb+43zCaZmi5KO4rAYaS8Ke0MP3IsIoG//cl4gwivC9ct/iONValoxXDLkjkachQmtYxTi68VzBJsWHKKQQZegR31lgBdVuKvzSeDwn9UN8SFm145wZpQxHK7vXcN5zRwFKhfhU+xEdWkFW46IjgcZ5hh9dczOPrP1JXPnUh7njjubdU775lvfz9db/4Yn1fyCillqvm1ovz1S/u8zynS88Tw0LaOu8m9aum93egJXrPsVu1Sv7dppbAPlUfuK6UvXSfNDEsqZjKISd1FYcxMxJ1+F5ZineovTc12tHP5UQNxWTxQMynN69P1bVvVR1H+A24Jwt2fkzq07kwVdn8eCrs3it+Xxm1H+LnDeFGm8foG8AXUK5apeOOpZUm1TEMIm9uLyvRGEt5SZOX0ORJJhOFCHCTwXvxbmPFQjdiofzWna5LWu9ibGTR2wiTvUc4UsAhBRr8LlguiSCO5lFRrI0F1o4b/HZtActLjNHSF7z3LzyZt6Ks5/+JeLSJ8WPqPgFkYz15BmHFtsHvXyZFm5Y0afPabUNPPSRL3HcjD35r3d+iFuOPLV47O4Vy7h+6SIKUcSGnm4+dscgKz0ZgyIIAr5z+51ksl7ZO/Vdc2a8/c4tN+ZwZ6vK4c5CJ++75+scds+ZHHbPmZw842j2a3gHjbkG6mSCk3RCoB5BJKlKsy5MOfX2iBBQcYpzXEAoH/qxH7ILjgsH+IpTd7y4rRBEXlwxr5CjJaimPaxgXU8d63pqWFeopTWsojmoobOQi7NJaAWhQhgJnUGW9YVqamV/2oNM0SCRBOS93DGeld0NdAdQ0MQWJXRH2aJukri6zaw7mquWnsr9a39BD1naqSIIYUnbXzd6fx9oOocCGUJ8WqIauqI4bDt938bVnBH/L/KP9bkr/eFNuAzqL42zVzTehVdZMmAsb/oYhfB1IKC95x80tV660TEagyfqfgo6tpLl3WRxvwwbS7Gqpuvs1jDQJ3QzKBRaaMs/WtzuKDxNR+FFfPHJZmYiqYw2QlKGOd6KHQzS+7RoV0ifU5xH2aveYXmx9UDwi35eISWF3JOInE6kRzaURWCnfYwBcoTkiX2ABeiO1ri2WXfJeIxZL/FbVgq97qa4bBRTK2cxq3YPPjTl3/juc2fGx1JW7BBo6acCXppnWl4qfmEl52c8pS5TxS6108l6Of684nFeaF3F9/c6kV1qJ7Osval4/mdnH9pvv5OravnxgUf32b94Q/nyXXuhn5RExmaz94WXUYgiqIzf+5WRx/v3nM1ph29agE5/qFknhjVbUw4DfPrRi0qyVOGHz99ApV/B7HFTeaZzOWlpGqqHpARf5ALqII6nK6iQ9YqRzX1MDZFzZiuEYTFIr1TBDnyyiF+IneJUioU6utRHgywdEr9XfYlIKuIB5MkQ5iO6tJI1UkNOSkaHtfkV1GerEdrJerE1e12+BvFiX7mOyGNStqdsnKHGkSqzahYwbdyh7DhuAX9f94HUvVDyZMgM0kLYE2VZE4wjQmjzcjzbM5M9axqYWzmOv3dkaX/5ExzUeBK71n2Gta0/Lc4r4+0wYJ9e1Qeh6oN99gdhU9l2d+HFQY3R2DhR19+g5QupPR5QDeN/sUX6N1ncP8NGKQYQkfOAU4AW4LAB2pwGnAaw446Dq6mej5ISlmm3hG5ChUKhtexYSZVNvIXVWVZToWMuN7GmlF5N9RGHq6nzK0sKbiio4IsCAXtO+BGPrftOH4U6z/pYFS9q3q4GnsSZLUQiKKueFHs6Z9MOG5K4T2gxSLA/Dms8mg9NO6W4XePX0uKWMovWmAh2q92TrrCLKr//csdzx+3EwuakQEdSrjSiJeigOWjjpbYNdIcFHlm7lDOfuI7XutbhizB73Hact8/xzKgt5S5e3LyaHzx1BzWZHD965zFMqKzuc70TZu/FxQsfKFqcj9xxzgAzNDaVde3tsUIMcWanarjshI9wyM4ztkDvY9PyMNIYjBx27TZZFrcVOknKJidyqivM82Lb64iKW/EqOaeFEWS8WJapCqHG1uNiXIe67O8S5/uVJAEwcQ7j7sAjK7FPcMn3t7QuOMmbzI4VlbzQ9VrxmgDdqmSLBonSkloYQU+YJSKHT4Tvh0T4lNzWfAoBrI7Gk/6+8Z2s6oqqyGcCci70r6AeTcEunDnzP5hQNbXX3Up/pygVMpsXW5cwp+6tXJiENcG42IUDWBfW0x7meLq9i1fzNTQXlqMo97z5Cx5cex+ruuYzu7KTd02Yx8zG88t6uuvNW1nU/Dh71O/LkVM+2u/VGus+w+qWC4vXnlx3er/tjM2g7T977Yjwtn+y36abjsnigRAdwhsjIn8Dtu/n0Nmq+pdUu7OASlX93lv1N3/+fH388ccHde0HX50Z9+22k5Aw0DIhm7wSIONNojtqphQeVzq3pIImQjp+HYuxpJCzUFKyUw4aGi+VBSpoKiBNwe2LvecihQCvGCiS5POMgG7NUrIxx2uMPana8Mk1kjyfXVHWlURNO4kI33jH5TTk4iwT3UE3Zy46ndAJ7NnVe/N0W6my0DfnnMnuDaVUdhct/i33romX4HpCv3QP3JJnpD6VXo6OgkdBw9iXL8wUf1zkPJ+HjjwH31VPag/yzLv5x0VLUl22gieO/UY//01o6mznt0ueZJf6iRw7a/d+2wyGFc0tfO/Ou6nIZDj3A0fQWNNXCR9LBEHAbhf8tGzfPV/4FNMaStHOIvKEqs7f1L7rvYl6YG4QZWmBO3uu36xrGBtnS8thGLws/vqTl/P4hheLMQ9J0ktJwnNFnVTWuNpmXMOO3Wuns6RjebEYRzw+ACXjxRIyiGLrctYLCUKPSBLZGlKbCSlEHkEE2cQtGCcnVanOBPheyjiiETlPi9cRDekKs0WLcKKw+gSMyxXK+quWTiIvS/rbxndW557IZ2KukwwhCnSGWdrCauoz9Vyy7yXF+/Twmht5YO3VAGTJ0Rruyoru1QDU+rVctO9lxbb5MM/XFn6RvPaQIWBm9driOCOFVfk6AvWZU5Wn4FK+FbSKrjBHqAEePvMmHM6x00pZJu5YdQu3rSot239gu2M5auq/9vs/be26l47uRxhf8y9U5mYP/M/fCLesfJC731zI/hPn8vGZ79vsfkYL0doTIHgqtSeD1yvAzmTxlmdILcWqesQgm14P3A5sVBgPhiCIl516xTO7DAkBnjjbsLNgJMFo+WiNa++5ELrEcizuVWLHFdKdERLiAAAOEklEQVSqZpyfwotTC5UdSVur4+p1Qa8fJbGrRpQK2yiNPLaGxNtZQgL8ooJZl9mBcRWzWd7xcPEHYOgU4BDPlZCOl+FKfcLVL/+Q9fkNzKyZy8dnfJXL5l1TvOr/ebI8t/AVy6/iv/e+gC88dQ5rejYQRMkdFbIS0hOV3k6Ru3ZPVKA2W08+DAg0JIg8Qmc1CVV5rOlVzn7yVnKez+lz35NyU4HWQnqZsZzJ1bV8fd/3DHh8MOSDgAVXXEPgLKMPvvoai776xbfV50gnk8lw7B67csuz8Y+h986aUaYQvx0U0CFKAyQiE4AbgRnAK8C/qWofPyARuQD4MPFH7y7gyzqUloJtwLaSwwBL2t+Iq9WljAzxpy/OMxxBsdR9gqryTNsK0AwisRKclH8GoRD6sSxymmkYuui3xJ2LDG15xfeS9b7yZeNQPdoKOWoy+aKbRU+YoSeEGlchrz2owkdd8F/caxRBl2bxAqj2C8Uqdf+935V8beEZbvUwUf1jeawIa3uqqfHzBPhFmdkStPCFJ86hM+zmlBkf5fDJJ3DgpBOKYzzt8U8UX7eH7SzasJBAM5y/+JeEGqJkgAzjvA429FRRl+tBEVoLlXSFWTKe4vu7otEiRDwyWk9X2O1uU0SgBS5Z8gceWvss+4yfjSeLy+7RwubHBlSK66oOo65qwAWFQXHzyge5eEkcu7Ko5WVaC52cMaev69yYouF3sHYe0AUINFy7xboeKlk8EuXwsHGfEJHZqrrUbR4DLH6r9ptK75LOMQFlAXOSetbSkTipT6IYl1wkiqWge/kneIrLblwS/EI6q0RJPc66COe0/zKiFFRTVonSGcm7xCPxLfaYlJ3L8bOuAGBF+9M823wH+0/4VxZuuIuHm28ujjF24UhGH9PU8yaBhixtf5b7mv7K+7c/PnXPyu9axstw4YtXsja/wVlxSj8zoqikhCczBqXKr+DGQ87kxdY3mF7TyC2vPckVy/4OwOmzD+OT/yx90M968i9FKztAtZ9la/Li2nVFhRigI18gHwTkMsPmY7FNuOCYI7ngmMFZETYJVRi6hPHfBu5W1fNF5Ntu+1vpBiJyMHAIsJfb9QBwKHDfUA1yuLG15fDkigY25DuTqwHlsQi9RuOCiRPDgudWm+Jyzzk/jshIAuaKpxf9M9IRHllwho1CKGT8eDUs/cO+I6hwFt1EtimEHlEUu8yl/dCiCLqdQtta8OkJM4yv6OKrs79ETaaGy+dfw62vx0re/PHzOevpcxEvyUAhvN41jvqUhTlSj9U9awH41Us3sG/DbozPDZxistKv4Oxnf1aWEx+gLapheVcFXneEL9Ad+WQloqGik3kTjmDOuM/SGTQzvmJHrnzpu2zIN1HhV/Ny2zjubHoIgHuanmSnqgaqUuJ3t/q92Jrc8+bCsu2/Nz0z5pViL5OB7bdSIZShk8UjTg4Pp2//80VkLrHkehXYYs5JmUyGKn8fusLyD55PNSHlAjpNYjVOrMKQ+BrH7Uu+x4kfbW+lEHpbh3vv6fNTyF2zvKfY9qxFC0tJEd+l+mAWTCv5gk2v3YvptfF7q7K9nrRFRgRyRBTIkPOqmF69O8+3xR+6QAu0B+kYG/ja3C9zznPfL1rDz5z7FS5YfBUAZbk/Sb6DyucpwK/mf5Vx2SrmTdwZgNPmHMYJMw5ARHio6eWy9hHKte8+mR8supPqTI5LDzqu993ZouzSOLGsOErO88a8Qry1GSpLMXFasfe6178hFrDf6tVGgUriZN4CZIHVQzO8YctWk8MAl877PEfe9123pUVrrwuf6IWW/fAuJ85Okchokdgqm/zu732Glr0WCmGmtCWlo1Exm0WJuGqeh0cUB8V52msVLw5uu/aAn5Wdd8zUkh9uS6EqttB6Ed1h1s05IotHY8VEVnR1kqRtE/HoCLrKlOIDJxzMw+sfBGBK5VTm1u1KOqol/Y1S6VfTEfa44Or4G2pqxU4c1HgoABMrYv/vL825hLagmdpMPSc9eG7Z2Jt6uvjkDh/k2dan2HXcXhw37WS2JvMnzmFRS+n7YM+GmVv1esaQyeIRJ4eH1Kd4SyMia4gF92ihEVi7rQexFRnt84OxMce5qjpuU08Skf8lvj+DoRLoTm3/SlU3njC7dK1mVW1IbW9Q1T6VaUTkQuAzxML4Z6p69mCvYZQYZbJ4LHyGbY6jg2Eti0eiHB7RZjFV3Xgd4hGEiDw+mh3aR/v8YOzMcXPOU9Ut6pPxVgFjgzx/F2BXYJrbdZeIvEdV799CQxwzjCZZPFY+wzbHkc9wkMWjTQ6PaKXYMIyxy1sFjInIahGZoqqrRGQKcXW23nwUeFhV2905/w84EDCl2DAMYxCMNjk8nCraGYZhbCluBZKQ/U8Af+mnzWvAoSKSEZEscXDHC/20MwzDMDadESeHTSkeXgzaZ3KEMtrnBzbH4cL5wAIRWQoscNuIyHwRudK1+RPwEvAMsAhYpKobr6VrjHZGwvv77WJzHB0M9zmOODk8ogPtDMMwDMMwDGNLYJZiwzAMwzAMY8xjSrFhGIZhGIYx5jGleIgQkatFpElEnk3tmyAid4nIUvc83u0XEfmJiCwTkadFZL9tN/LBIyLTReReEXlBRJ4TkS+7/aNmniJSKSKPisgiN8fvu/0zReQRN8cbRSTn9le47WXu+IxtOf7BIiK+iDwlIre57VE1P2PsMtplscnh0SWnTBYPLaYUDx3XAL1zAyYlEGcDd7ttgA8Cs93jNOAXQzTGt0sAnKmquxKnVDlDRHZjdM2zBzhcVfcG9gGOFJEDgR8BF7s5bgBOde1PBTao6i7Axa7dSODLlEcAj7b5GWOXaxjdstjk8OiSUyaLhxJVtccQPYAZwLOp7SXAFPd6CrDEvb4c+Fh/7UbSgzj9yoLROk+gGngSOIC4clLG7T8IuMO9vgM4yL3OuHayrce+kXlNI/7SPBy4jbjK0KiZnz3sMZZkscnhkSunTBYP/cMsxduW7VR1FYB7nuz2TwVWpNqtdPtGDG7pZl/gEUbZPN1y1kLiROR3EaeTaVbVwDVJz6M4R3e8BZg4tCPeZC4BvglEbnsio2t+htGbUSWjEkwOj3g5ZbJ4iDGleHgi/ewbMbnzRKQWuAn4iqq2vlXTfvYN+3mqaqiq+xD/it+fuERln2bueUTNUUSOAppU9Yn07n6ajsj5GcYmMmLf3yaH42buecTN0WTxtsGU4m3LaolLHyLlJRBXAtNT7aYBbwzx2DYLiSvS3AT8TlX/7HaPunkCqGozcB+x316DiCRl09PzKM7RHa8H1g/tSDeJQ4BjROQV4PfEy3aXMHrmZxj9MapklMlhYOTLKZPF2wBTirctA5VAvBU4xUUFHwi0JMtewxkREeAq4AVVvSh1aNTMU0QmiUiDe10FHEEcBHEvcLxr1nuOydyPB+5R5/Q1HFHVs1R1mqrOAE4kHu9JjJL5GcYAjCYZZXI4ZkTLKZPF24ht7dQ8Vh7ADcAqoED8i+5UYn+fu4Gl7nmCayvAZZRKH87f1uMf5BzfRbxc8zSw0D0+NJrmCewFPOXm+Cxwjts/C3gUWAb8Eahw+yvd9jJ3fNa2nsMmzPW9wG2jdX72GJuP0S6LTQ6PPjllsnjoHlbm2TAMwzAMwxjzmPuEYRiGYRiGMeYxpdgwDMMwDMMY85hSbBiGYRiGYYx5TCk2DMMwDMMwxjymFBuGYRiGYRhjHlOKDcMwDMMwjDGPKcWGYRiGYRjGmMeUYmNIEZEZItIlIgtT+7YTketFZLmIPCEiD4nIR9+ij/tE5AO99n1FRH4uIlUislBE8iLSuDXnYhiGMVIxWWwYfTGl2NgWvKSq+0CxJOktwP2qOktV5xGXtJz2Fuff4NqkORG4QVW7XN9v9D3NMAzDSGGy2DBSmFJs9EFEfi8iN4rIIyLyqoh8eCte7nAgr6q/THao6quq+lM3lpNF5FFncbhcRHzgT8BRIlLh2swAdgAe2IrjNAzDGFJMFhvG0GJKsdEfewPLVfUA4CTge1vxWrsDT/Z3QER2BU4ADnEWhxA4SVXXEdd2P9I1PRG4Ua1muWEYowuTxYYxhJhSbJQhIlVAI/B9t+t5YLyIfEpEfikiL7vnz/Vz7g9EZJaIXCUif9rM618mIotE5DHgfcA84DHn9/Y+YJZrml62O9FtG4ZhjApMFhvG0JPZ1gMwhh17AEtVtdtt7wcsUtVfi8hfgIyqnt77JBGZDORUdTlw6iYI4ueAf0k2VPUMF5TxOCDAb1T1rH7OuwW4SET2A6pUtV8Lh2EYxgjFZLFhDDFmKTZ6szewo4hUikgNsZXiYndsHgMsrwHvBJ7YjOvdA1SKyOdT+6rd893A8U7IIyITRGQnAFVtB+4DrsYsE4ZhjD5MFhvGEGNKsdGbvYHfEQu5x4BfqOo/3bF5DCxs30lsUdgknO/ZscChbjnwUeA3wLdU9Xng/wJ3isjTwF3AlNTpN7jx/n5Tr2sYhjHMMVlsGEOMmD+8kUZE7gc+q6pL+jl2A/BpVe0Ske2Ao1T1KnfsN6r6CRGZCJwHLACuVNUf9upjBnCbqu6xlefxCjBfVdduzesYhmFsDUwWG8bQYz7FRm92Bpb2d0BVP5ba3Bd4GUBEzgCWuTbrgD5+bilCoF5EFib5MbckLjjlISALRFu6f8MwjCHCZLFhDDFmKTYMwzAMwzDGPOZTbBiGYRiGYYx5TCk2DMMwDMMwxjymFBuGYRiGYRhjHlOKDcMwDMMwjDGPKcWGYRiGYRjGmMeUYsMwDMMwDGPMY0qxYRiGYRiGMeYxpdgwDMMwDMMY8/x/kxjM7YuG5UsAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -441,13 +360,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "11:53 madminer.fisherinfor INFO Loading data from data/madminer_example_shuffled.h5\n", - "11:53 madminer.fisherinfor INFO Found 2 parameters\n", - "11:53 madminer.fisherinfor WARNING Did not find nuisance parameters!\n", - "11:53 madminer.fisherinfor INFO Found 6 benchmarks, of which 6 physical\n", - "11:53 madminer.fisherinfor INFO Found 2 observables: pt_j1, delta_phi_jj\n", - "11:53 madminer.fisherinfor INFO Found 6537 events\n", - "11:53 madminer.fisherinfor INFO Found morphing setup with 6 components\n" + "15:39 madminer.analysis INFO Loading data from data/madminer_example_shuffled.h5\n", + "15:39 madminer.analysis INFO Found 2 parameters\n", + "15:39 madminer.analysis INFO Did not find nuisance parameters\n", + "15:39 madminer.analysis INFO Found 6 benchmarks, of which 6 physical\n", + "15:39 madminer.analysis INFO Found 2 observables\n", + "15:39 madminer.analysis INFO Found 6537 events\n", + "15:39 madminer.analysis INFO Found morphing setup with 6 components\n" ] } ], @@ -464,25 +383,29 @@ "name": "stderr", "output_type": "stream", "text": [ - "11:53 madminer.fisherinfor INFO Evaluating rate Fisher information\n", - "11:53 madminer.utils.inter WARNING include_nuisance_parameters=False without benchmark_is_nuisance information. Returning all weights.\n" + "15:39 madminer.fisherinfor INFO Evaluating rate Fisher information\n", + "15:39 madminer.utils.inter WARNING include_nuisance_parameters=False without benchmark_is_nuisance information. Returning all weights.\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Kinematic Fisher information after 3000 ifb:\n", - "[[70.14907905 15.70474489]\n", - " [15.70474489 68.36131458]]\n" - ] + "ename": "AttributeError", + "evalue": "'NoneType' object has no attribute 'calculate_a'", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mtheta\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0.\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mmodel_file\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'models/sally'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mluminosity\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3000000.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m )\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Users/johannbrehmer/work/projects/madminer/madminer/madminer/fisherinformation.pyc\u001b[0m in \u001b[0;36mcalculate_fisher_information_full_detector\u001b[0;34m(self, theta, model_file, unweighted_x_sample_file, luminosity, include_xsec_info, mode, calculate_covariance, batch_size, test_split)\u001b[0m\n\u001b[1;32m 257\u001b[0m \u001b[0mlogger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minfo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Evaluating rate Fisher information\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 258\u001b[0m fisher_info_rate, rate_covariance = self.calculate_fisher_information_rate(\n\u001b[0;32m--> 259\u001b[0;31m \u001b[0mtheta\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtheta\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mluminosity\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mluminosity\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minclude_nuisance_parameters\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minclude_nuisance_parameters\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 260\u001b[0m )\n\u001b[1;32m 261\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Users/johannbrehmer/work/projects/madminer/madminer/madminer/fisherinformation.pyc\u001b[0m in \u001b[0;36mcalculate_fisher_information_rate\u001b[0;34m(self, theta, luminosity, cuts, efficiency_functions, include_nuisance_parameters)\u001b[0m\n\u001b[1;32m 413\u001b[0m \u001b[0msum_events\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 414\u001b[0m \u001b[0mcalculate_uncertainty\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 415\u001b[0;31m \u001b[0mweights_benchmark_uncertainties\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mweights_benchmark_uncertainties\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 416\u001b[0m )\n\u001b[1;32m 417\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Users/johannbrehmer/work/projects/madminer/madminer/madminer/fisherinformation.pyc\u001b[0m in \u001b[0;36m_calculate_fisher_information\u001b[0;34m(self, theta, weights_benchmarks, luminosity, include_nuisance_parameters, sum_events, calculate_uncertainty, weights_benchmark_uncertainties)\u001b[0m\n\u001b[1;32m 1041\u001b[0m \u001b[0;31m# Nuisance parameter Fisher info\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1042\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0minclude_nuisance_parameters\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minclude_nuisance_parameters\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1043\u001b[0;31m \u001b[0mnuisance_a\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnuisance_morpher\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalculate_a\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mweights_benchmarks\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Shape (n_nuisance_params, n_events)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1044\u001b[0m \u001b[0;31m# grad_i dsigma(x), where i is a nuisance parameter, is given by\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1045\u001b[0m \u001b[0;31m# sigma[np.newaxis, :] * a\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'calculate_a'" + ], + "output_type": "error" } ], "source": [ "fisher_information, _ = fisher.calculate_fisher_information_full_detector(\n", " theta=[0.,0.],\n", " model_file='models/sally',\n", - " unweighted_x_sample_file='data/samples/x_test.npy',\n", " luminosity=3000000.\n", ")\n", "\n", @@ -498,32 +421,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/johannbrehmer/anaconda3/envs/python2/lib/python2.7/site-packages/matplotlib/contour.py:1004: UserWarning: The following kwargs were not used by contour: 'label'\n", - " s)\n", - "/Users/johannbrehmer/anaconda3/envs/python2/lib/python2.7/site-packages/matplotlib/cbook/deprecation.py:107: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", - " warnings.warn(message, mplDeprecation, stacklevel=1)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "_ = plot_fisher_information_contours_2d(\n", " [fisher_information],\n", @@ -548,11 +448,13 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "ensemble = EnsembleForge(estimators=5)" + "estimators = [ScoreEstimator(n_hidden=(20,)) for _ in range(5)]\n", + "\n", + "ensemble = Ensemble(estimators)" ] }, { @@ -571,257 +473,17 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": { "scrolled": false }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "11:54 madminer.ml INFO Training 5 estimators in ensemble\n", - "11:54 madminer.ml INFO Training estimator 1 / 5 in ensemble\n", - "11:54 madminer.ml INFO Starting training\n", - "11:54 madminer.ml INFO Method: sally\n", - "11:54 madminer.ml INFO Training data: x at data/samples/x_train.npy\n", - "11:54 madminer.ml INFO t_xz (theta0) at data/samples/t_xz_train.npy\n", - "11:54 madminer.ml INFO Features: all\n", - "11:54 madminer.ml INFO Method: sally\n", - "11:54 madminer.ml INFO Hidden layers: (100, 100, 100)\n", - "11:54 madminer.ml INFO Activation function: tanh\n", - "11:54 madminer.ml INFO Batch size: 200\n", - "11:54 madminer.ml INFO Optimizer: amsgrad\n", - "11:54 madminer.ml INFO Epochs: 10\n", - "11:54 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "11:54 madminer.ml INFO Validation split: 0.25\n", - "11:54 madminer.ml INFO Early stopping: True\n", - "11:54 madminer.ml INFO Scale inputs: True\n", - "11:54 madminer.ml INFO Shuffle labels False\n", - "11:54 madminer.ml INFO Samples: all\n", - "11:54 madminer.ml INFO Loading training data\n", - "11:54 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", - "11:54 madminer.ml INFO Rescaling inputs\n", - "11:54 madminer.ml INFO Creating model for method sally\n", - "11:54 madminer.ml INFO Training model\n", - "11:54 madminer.utils.ml.tr INFO Epoch 1: train loss 0.14047 (mse_score: 0.140)\n", - "11:54 madminer.utils.ml.tr INFO val. loss 0.10298 (mse_score: 0.103)\n", - "11:54 madminer.utils.ml.tr INFO Epoch 2: train loss 0.10709 (mse_score: 0.107)\n", - "11:54 madminer.utils.ml.tr INFO val. loss 0.09808 (mse_score: 0.098)\n", - "11:54 madminer.utils.ml.tr INFO Epoch 3: train loss 0.10139 (mse_score: 0.101)\n", - "11:54 madminer.utils.ml.tr INFO val. loss 0.09723 (mse_score: 0.097)\n", - "11:54 madminer.utils.ml.tr INFO Epoch 4: train loss 0.09838 (mse_score: 0.098)\n", - "11:54 madminer.utils.ml.tr INFO val. loss 0.09475 (mse_score: 0.095)\n", - "11:54 madminer.utils.ml.tr INFO Epoch 5: train loss 0.09645 (mse_score: 0.096)\n", - "11:54 madminer.utils.ml.tr INFO val. loss 0.09134 (mse_score: 0.091)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 6: train loss 0.09478 (mse_score: 0.095)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.09197 (mse_score: 0.092)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 7: train loss 0.09360 (mse_score: 0.094)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.09069 (mse_score: 0.091)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 8: train loss 0.09290 (mse_score: 0.093)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.09046 (mse_score: 0.090)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 9: train loss 0.09208 (mse_score: 0.092)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.08945 (mse_score: 0.089)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 10: train loss 0.09175 (mse_score: 0.092)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.08943 (mse_score: 0.089)\n", - "11:55 madminer.utils.ml.tr INFO Early stopping did not improve performance\n", - "11:55 madminer.ml INFO Training estimator 2 / 5 in ensemble\n", - "11:55 madminer.ml INFO Starting training\n", - "11:55 madminer.ml INFO Method: sally\n", - "11:55 madminer.ml INFO Training data: x at data/samples/x_train.npy\n", - "11:55 madminer.ml INFO t_xz (theta0) at data/samples/t_xz_train.npy\n", - "11:55 madminer.ml INFO Features: all\n", - "11:55 madminer.ml INFO Method: sally\n", - "11:55 madminer.ml INFO Hidden layers: (100, 100, 100)\n", - "11:55 madminer.ml INFO Activation function: tanh\n", - "11:55 madminer.ml INFO Batch size: 200\n", - "11:55 madminer.ml INFO Optimizer: amsgrad\n", - "11:55 madminer.ml INFO Epochs: 10\n", - "11:55 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "11:55 madminer.ml INFO Validation split: 0.25\n", - "11:55 madminer.ml INFO Early stopping: True\n", - "11:55 madminer.ml INFO Scale inputs: True\n", - "11:55 madminer.ml INFO Shuffle labels False\n", - "11:55 madminer.ml INFO Samples: all\n", - "11:55 madminer.ml INFO Loading training data\n", - "11:55 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", - "11:55 madminer.ml INFO Rescaling inputs\n", - "11:55 madminer.ml INFO Creating model for method sally\n", - "11:55 madminer.ml INFO Training model\n", - "11:55 madminer.utils.ml.tr INFO Epoch 1: train loss 0.13218 (mse_score: 0.132)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.11648 (mse_score: 0.116)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 2: train loss 0.10358 (mse_score: 0.104)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.10520 (mse_score: 0.105)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 3: train loss 0.09927 (mse_score: 0.099)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.10344 (mse_score: 0.103)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 4: train loss 0.09716 (mse_score: 0.097)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.09833 (mse_score: 0.098)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 5: train loss 0.09533 (mse_score: 0.095)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.09678 (mse_score: 0.097)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 6: train loss 0.09436 (mse_score: 0.094)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.09660 (mse_score: 0.097)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 7: train loss 0.09348 (mse_score: 0.093)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.09560 (mse_score: 0.096)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 8: train loss 0.09270 (mse_score: 0.093)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.09529 (mse_score: 0.095)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 9: train loss 0.09228 (mse_score: 0.092)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.09457 (mse_score: 0.095)\n", - "11:55 madminer.utils.ml.tr INFO Epoch 10: train loss 0.09191 (mse_score: 0.092)\n", - "11:55 madminer.utils.ml.tr INFO val. loss 0.09379 (mse_score: 0.094)\n", - "11:55 madminer.utils.ml.tr INFO Early stopping did not improve performance\n", - "11:55 madminer.ml INFO Training estimator 3 / 5 in ensemble\n", - "11:55 madminer.ml INFO Starting training\n", - "11:55 madminer.ml INFO Method: sally\n", - "11:55 madminer.ml INFO Training data: x at data/samples/x_train.npy\n", - "11:55 madminer.ml INFO t_xz (theta0) at data/samples/t_xz_train.npy\n", - "11:55 madminer.ml INFO Features: all\n", - "11:55 madminer.ml INFO Method: sally\n", - "11:55 madminer.ml INFO Hidden layers: (100, 100, 100)\n", - "11:55 madminer.ml INFO Activation function: tanh\n", - "11:55 madminer.ml INFO Batch size: 200\n", - "11:55 madminer.ml INFO Optimizer: amsgrad\n", - "11:55 madminer.ml INFO Epochs: 10\n", - "11:55 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "11:55 madminer.ml INFO Validation split: 0.25\n", - "11:55 madminer.ml INFO Early stopping: True\n", - "11:55 madminer.ml INFO Scale inputs: True\n", - "11:55 madminer.ml INFO Shuffle labels False\n", - "11:55 madminer.ml INFO Samples: all\n", - "11:55 madminer.ml INFO Loading training data\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "11:55 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", - "11:55 madminer.ml INFO Rescaling inputs\n", - "11:55 madminer.ml INFO Creating model for method sally\n", - "11:55 madminer.ml INFO Training model\n", - "11:56 madminer.utils.ml.tr INFO Epoch 1: train loss 0.13724 (mse_score: 0.137)\n", - "11:56 madminer.utils.ml.tr INFO val. loss 0.11112 (mse_score: 0.111)\n", - "11:56 madminer.utils.ml.tr INFO Epoch 2: train loss 0.10583 (mse_score: 0.106)\n", - "11:56 madminer.utils.ml.tr INFO val. loss 0.10091 (mse_score: 0.101)\n", - "11:56 madminer.utils.ml.tr INFO Epoch 3: train loss 0.10046 (mse_score: 0.100)\n", - "11:56 madminer.utils.ml.tr INFO val. loss 0.09737 (mse_score: 0.097)\n", - "11:56 madminer.utils.ml.tr INFO Epoch 4: train loss 0.09774 (mse_score: 0.098)\n", - "11:56 madminer.utils.ml.tr INFO val. loss 0.09451 (mse_score: 0.095)\n", - "11:56 madminer.utils.ml.tr INFO Epoch 5: train loss 0.09596 (mse_score: 0.096)\n", - "11:56 madminer.utils.ml.tr INFO val. loss 0.09400 (mse_score: 0.094)\n", - "11:56 madminer.utils.ml.tr INFO Epoch 6: train loss 0.09471 (mse_score: 0.095)\n", - "11:56 madminer.utils.ml.tr INFO val. loss 0.09203 (mse_score: 0.092)\n", - "11:56 madminer.utils.ml.tr INFO Epoch 7: train loss 0.09348 (mse_score: 0.093)\n", - "11:56 madminer.utils.ml.tr INFO val. loss 0.09231 (mse_score: 0.092)\n", - "11:56 madminer.utils.ml.tr INFO Epoch 8: train loss 0.09290 (mse_score: 0.093)\n", - "11:56 madminer.utils.ml.tr INFO val. loss 0.09315 (mse_score: 0.093)\n", - "11:56 madminer.utils.ml.tr INFO Epoch 9: train loss 0.09225 (mse_score: 0.092)\n", - "11:56 madminer.utils.ml.tr INFO val. loss 0.09074 (mse_score: 0.091)\n", - "11:56 madminer.utils.ml.tr INFO Epoch 10: train loss 0.09176 (mse_score: 0.092)\n", - "11:56 madminer.utils.ml.tr INFO val. loss 0.09156 (mse_score: 0.092)\n", - "11:56 madminer.utils.ml.tr INFO Early stopping did not improve performance\n", - "11:56 madminer.ml INFO Training estimator 4 / 5 in ensemble\n", - "11:56 madminer.ml INFO Starting training\n", - "11:56 madminer.ml INFO Method: sally\n", - "11:56 madminer.ml INFO Training data: x at data/samples/x_train.npy\n", - "11:56 madminer.ml INFO t_xz (theta0) at data/samples/t_xz_train.npy\n", - "11:56 madminer.ml INFO Features: all\n", - "11:56 madminer.ml INFO Method: sally\n", - "11:56 madminer.ml INFO Hidden layers: (100, 100, 100)\n", - "11:56 madminer.ml INFO Activation function: tanh\n", - "11:56 madminer.ml INFO Batch size: 200\n", - "11:56 madminer.ml INFO Optimizer: amsgrad\n", - "11:56 madminer.ml INFO Epochs: 10\n", - "11:56 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "11:56 madminer.ml INFO Validation split: 0.25\n", - "11:56 madminer.ml INFO Early stopping: True\n", - "11:56 madminer.ml INFO Scale inputs: True\n", - "11:56 madminer.ml INFO Shuffle labels False\n", - "11:56 madminer.ml INFO Samples: all\n", - "11:56 madminer.ml INFO Loading training data\n", - "11:56 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", - "11:56 madminer.ml INFO Rescaling inputs\n", - "11:56 madminer.ml INFO Creating model for method sally\n", - "11:56 madminer.ml INFO Training model\n", - "11:56 madminer.utils.ml.tr INFO Epoch 1: train loss 0.13115 (mse_score: 0.131)\n", - "11:56 madminer.utils.ml.tr INFO val. loss 0.11818 (mse_score: 0.118)\n", - "11:56 madminer.utils.ml.tr INFO Epoch 2: train loss 0.10282 (mse_score: 0.103)\n", - "11:56 madminer.utils.ml.tr INFO val. loss 0.10607 (mse_score: 0.106)\n", - "11:56 madminer.utils.ml.tr INFO Epoch 3: train loss 0.09835 (mse_score: 0.098)\n", - "11:56 madminer.utils.ml.tr INFO val. loss 0.10730 (mse_score: 0.107)\n", - "11:57 madminer.utils.ml.tr INFO Epoch 4: train loss 0.09604 (mse_score: 0.096)\n", - "11:57 madminer.utils.ml.tr INFO val. loss 0.10177 (mse_score: 0.102)\n", - "11:57 madminer.utils.ml.tr INFO Epoch 5: train loss 0.09448 (mse_score: 0.094)\n", - "11:57 madminer.utils.ml.tr INFO val. loss 0.10045 (mse_score: 0.100)\n", - "11:57 madminer.utils.ml.tr INFO Epoch 6: train loss 0.09323 (mse_score: 0.093)\n", - "11:57 madminer.utils.ml.tr INFO val. loss 0.09987 (mse_score: 0.100)\n", - "11:57 madminer.utils.ml.tr INFO Epoch 7: train loss 0.09210 (mse_score: 0.092)\n", - "11:57 madminer.utils.ml.tr INFO val. loss 0.09916 (mse_score: 0.099)\n", - "11:57 madminer.utils.ml.tr INFO Epoch 8: train loss 0.09150 (mse_score: 0.091)\n", - "11:57 madminer.utils.ml.tr INFO val. loss 0.09832 (mse_score: 0.098)\n", - "11:57 madminer.utils.ml.tr INFO Epoch 9: train loss 0.09087 (mse_score: 0.091)\n", - "11:57 madminer.utils.ml.tr INFO val. loss 0.09678 (mse_score: 0.097)\n", - "11:57 madminer.utils.ml.tr INFO Epoch 10: train loss 0.09051 (mse_score: 0.091)\n", - "11:57 madminer.utils.ml.tr INFO val. loss 0.09635 (mse_score: 0.096)\n", - "11:57 madminer.utils.ml.tr INFO Early stopping did not improve performance\n", - "11:57 madminer.ml INFO Training estimator 5 / 5 in ensemble\n", - "11:57 madminer.ml INFO Starting training\n", - "11:57 madminer.ml INFO Method: sally\n", - "11:57 madminer.ml INFO Training data: x at data/samples/x_train.npy\n", - "11:57 madminer.ml INFO t_xz (theta0) at data/samples/t_xz_train.npy\n", - "11:57 madminer.ml INFO Features: all\n", - "11:57 madminer.ml INFO Method: sally\n", - "11:57 madminer.ml INFO Hidden layers: (100, 100, 100)\n", - "11:57 madminer.ml INFO Activation function: tanh\n", - "11:57 madminer.ml INFO Batch size: 200\n", - "11:57 madminer.ml INFO Optimizer: amsgrad\n", - "11:57 madminer.ml INFO Epochs: 10\n", - "11:57 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "11:57 madminer.ml INFO Validation split: 0.25\n", - "11:57 madminer.ml INFO Early stopping: True\n", - "11:57 madminer.ml INFO Scale inputs: True\n", - "11:57 madminer.ml INFO Shuffle labels False\n", - "11:57 madminer.ml INFO Samples: all\n", - "11:57 madminer.ml INFO Loading training data\n", - "11:57 madminer.ml INFO Found 100000 samples with 2 parameters and 2 observables\n", - "11:57 madminer.ml INFO Rescaling inputs\n", - "11:57 madminer.ml INFO Creating model for method sally\n", - "11:57 madminer.ml INFO Training model\n", - "11:57 madminer.utils.ml.tr INFO Epoch 1: train loss 0.13555 (mse_score: 0.136)\n", - "11:57 madminer.utils.ml.tr INFO val. loss 0.10889 (mse_score: 0.109)\n", - "11:57 madminer.utils.ml.tr INFO Epoch 2: train loss 0.10552 (mse_score: 0.106)\n", - "11:57 madminer.utils.ml.tr INFO val. loss 0.10303 (mse_score: 0.103)\n", - "11:57 madminer.utils.ml.tr INFO Epoch 3: train loss 0.10057 (mse_score: 0.101)\n", - "11:57 madminer.utils.ml.tr INFO val. loss 0.09798 (mse_score: 0.098)\n", - "11:57 madminer.utils.ml.tr INFO Epoch 4: train loss 0.09764 (mse_score: 0.098)\n", - "11:57 madminer.utils.ml.tr INFO val. loss 0.09603 (mse_score: 0.096)\n", - "11:57 madminer.utils.ml.tr INFO Epoch 5: train loss 0.09553 (mse_score: 0.096)\n", - "11:57 madminer.utils.ml.tr INFO val. loss 0.09404 (mse_score: 0.094)\n", - "11:58 madminer.utils.ml.tr INFO Epoch 6: train loss 0.09460 (mse_score: 0.095)\n", - "11:58 madminer.utils.ml.tr INFO val. loss 0.09326 (mse_score: 0.093)\n", - "11:58 madminer.utils.ml.tr INFO Epoch 7: train loss 0.09309 (mse_score: 0.093)\n", - "11:58 madminer.utils.ml.tr INFO val. loss 0.09360 (mse_score: 0.094)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "11:58 madminer.utils.ml.tr INFO Epoch 8: train loss 0.09235 (mse_score: 0.092)\n", - "11:58 madminer.utils.ml.tr INFO val. loss 0.09164 (mse_score: 0.092)\n", - "11:58 madminer.utils.ml.tr INFO Epoch 9: train loss 0.09163 (mse_score: 0.092)\n", - "11:58 madminer.utils.ml.tr INFO val. loss 0.09133 (mse_score: 0.091)\n", - "11:58 madminer.utils.ml.tr INFO Epoch 10: train loss 0.09127 (mse_score: 0.091)\n", - "11:58 madminer.utils.ml.tr INFO val. loss 0.09110 (mse_score: 0.091)\n", - "11:58 madminer.utils.ml.tr INFO Early stopping did not improve performance\n" - ] - } - ], + "outputs": [], "source": [ "ensemble.train_all(\n", " method='sally',\n", - " x_filename='data/samples/x_train.npy',\n", - " t_xz0_filename='data/samples/t_xz_train.npy',\n", - " n_epochs=10,\n", + " x='data/samples/x_train.npy',\n", + " t_xz='data/samples/t_xz_train.npy',\n", + " n_epochs=5,\n", ")\n", "\n", "ensemble.save('models/sally_ensemble')" @@ -848,28 +510,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "12:12 madminer.fisherinfor INFO Loading data from data/madminer_example_shuffled.h5\n", - "12:12 madminer.fisherinfor INFO Found 2 parameters\n", - "12:12 madminer.fisherinfor WARNING Did not find nuisance parameters!\n", - "12:12 madminer.fisherinfor INFO Found 6 benchmarks, of which 6 physical\n", - "12:12 madminer.fisherinfor INFO Found 2 observables: pt_j1, delta_phi_jj\n", - "12:12 madminer.fisherinfor INFO Found 6537 events\n", - "12:12 madminer.fisherinfor INFO Found morphing setup with 6 components\n", - "12:12 madminer.ml INFO Found ensemble with 5 estimators and expectations None\n", - "12:12 madminer.fisherinfor INFO Evaluating rate Fisher information\n", - "12:12 madminer.utils.inter WARNING include_nuisance_parameters=False without benchmark_is_nuisance information. Returning all weights.\n", - "12:12 madminer.utils.inter WARNING include_nuisance_parameters=False without benchmark_is_nuisance information. Returning all weights.\n", - "12:12 madminer.fisherinfor INFO Evaluating kinematic Fisher information on batch 1 / 1\n" - ] - } - ], + "outputs": [], "source": [ "fisher = FisherInformation('data/madminer_example_shuffled.h5')\n", "\n", @@ -890,22 +533,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "_ = plot_fisher_information_contours_2d(\n", " [fisher_information_mean],\n", diff --git a/examples/tutorial_parton_level/3_systematic_uncertainties.ipynb b/examples/tutorial_parton_level/3_systematic_uncertainties.ipynb new file mode 100755 index 000000000..d1f706149 --- /dev/null +++ b/examples/tutorial_parton_level/3_systematic_uncertainties.ipynb @@ -0,0 +1,366 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MadMiner parton-level tutorial, part 3: Systematic uncertainties\n", + "\n", + "Johann Brehmer, Felix Kling, Kyle Cranmer 2018" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this tutorial we'll explain how to add systematic uncertainties to the MadMiner workflow." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preparations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before you execute this notebook, make sure you have running installations of MadGraph, Pythia, and Delphes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import absolute_import, division, print_function, unicode_literals\n", + "\n", + "import logging\n", + "import numpy as np\n", + "import matplotlib\n", + "from matplotlib import pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from madminer.core import MadMiner\n", + "from madminer.lhe import LHEReader\n", + "from madminer.sampling import combine_and_shuffle\n", + "from madminer.sampling import SampleAugmenter\n", + "from madminer import sampling\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Please enter here the path to your MG5 root directory." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mg_dir = '/Users/johannbrehmer/work/projects/madminer/MG5_aMC_v2_6_4'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "MadMiner uses the Python `logging` module to provide additional information and debugging output. You can choose how much of this output you want to see by switching the level in the following lines to `logging.DEBUG` or `logging.WARNING`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# MadMiner output\n", + "logging.basicConfig(\n", + " format='%(asctime)-5.5s %(name)-20.20s %(levelname)-7.7s %(message)s',\n", + " datefmt='%H:%M',\n", + " level=logging.INFO\n", + ")\n", + "\n", + "# Output of all other modules (e.g. matplotlib)\n", + "for key in logging.Logger.manager.loggerDict:\n", + " if \"madminer\" not in key:\n", + " logging.getLogger(key).setLevel(logging.WARNING)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1.-2. Parameters and benchmarks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll just load the MadMiner setup from the first part of this tutorial:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "miner = MadMiner()\n", + "miner.load('data/madminer_example.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Set up systematics, save settings, run MadGraph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is where things become interesting: We want to model systematic uncertainties. Currently this can be done in one of two ways: based on scale variation or based on PDF variations. You can also use both simultaneously. Here we just vary the scales:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "miner.set_systematics(scale_variation=(0.5,2.), pdf_variation=None)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we save our setup:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "miner.save('data/madminer_example_systematics.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now it's time to run MadGraph. MadMiner will instruct MadGraph to use its built-in `systematics` tool to calculate how the event weights change under the scale variation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "miner.run(\n", + " sample_benchmark='sm',\n", + " mg_directory=mg_dir,\n", + " mg_process_directory='./mg_processes/signal_systematics',\n", + " proc_card_file='cards/proc_card_signal.dat',\n", + " param_card_template_file='cards/param_card_template.dat',\n", + " run_card_file='cards/run_card_signal.dat',\n", + " log_directory='logs/signal',\n", + " python2_override=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Run smearing and extract observables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is just as before:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lhe = LHEReader('data/madminer_example_systematics.h5')\n", + "\n", + "lhe.add_sample(\n", + " lhe_filename='mg_processes/signal_systematics/Events/run_01/unweighted_events.lhe.gz',\n", + " sampled_from_benchmark='sm',\n", + " is_background=False,\n", + " k_factor=1.1,\n", + ")\n", + "\n", + "lhe.set_smearing(\n", + " pdgids=[1,2,3,4,5,6,9,22,-1,-2,-3,-4,-5,-6], # Partons giving rise to jets\n", + " energy_resolution_abs=0.,\n", + " energy_resolution_rel=0.1,\n", + " pt_resolution_abs=None,\n", + " pt_resolution_rel=None,\n", + " eta_resolution_abs=0.1,\n", + " eta_resolution_rel=0.,\n", + " phi_resolution_abs=0.1,\n", + " phi_resolution_rel=0.,\n", + ")\n", + "\n", + "lhe.add_observable(\n", + " 'pt_j1',\n", + " 'j[0].pt',\n", + " required=False,\n", + " default=0.,\n", + ")\n", + "lhe.add_observable(\n", + " 'delta_phi_jj',\n", + " 'j[0].deltaphi(j[1]) * (-1. + 2.*float(j[0].eta > j[1].eta))',\n", + " required=True,\n", + ")\n", + "lhe.add_observable(\n", + " 'met',\n", + " 'met.pt',\n", + " required=True,\n", + ")\n", + "\n", + "lhe.add_cut('(a[0] + a[1]).m > 124.')\n", + "lhe.add_cut('(a[0] + a[1]).m < 126.')\n", + "lhe.add_cut('pt_j1 > 30.')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "lhe.analyse_samples()\n", + "lhe.save('data/madminer_example_systematics_with_data.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A look at distributions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see what our MC run produced:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "_ = plot_uncertainty(\n", + " filename='data/madminer_example_systematics_with_data.h5',\n", + " parameter_points=['sm', np.array([10.,0.])],\n", + " line_labels=['SM', 'BSM'],\n", + " uncertainties='none',\n", + " n_bins=20,\n", + " n_cols=3,\n", + " normalize=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Make (unweighted) training and test samples with augmented data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sampler = SampleAugmenter('data/madminer_example_systematics_with_data.h5')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When we generate training data, we now also have to specify the values of the nuisance parameters. The helper functions `sampling.nominal_nuisance_parameters()` and `sampling.iid_nuisance_parameters()` can be used in addition to the usual ones. The `theta0` and `theta1` return now includes values for the nuisance parameters." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x, theta0, theta1, y, r_xz, t_xz, _ = sampler.sample_train_ratio(\n", + " theta0=sampling.random_morphing_points(100, [('gaussian', 0., 15.), ('gaussian', 0., 15.)]),\n", + " theta1=sampling.benchmark('sm'),\n", + " nu0=sampling.iid_nuisance_parameters(\"gaussian\", 0., 1.),\n", + " nu1=sampling.nominal_nuisance_parameters(),\n", + " n_samples=1000,\n", + " folder='./data/samples',\n", + " filename='train'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To be continued..." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/tutorial_parton_level/debug.py b/examples/tutorial_parton_level/debug.py new file mode 100644 index 000000000..d230f50a7 --- /dev/null +++ b/examples/tutorial_parton_level/debug.py @@ -0,0 +1,27 @@ +#! /usr/bin/env python + +from __future__ import absolute_import, division, print_function, unicode_literals + +import logging +logging.basicConfig( + format='%(asctime)-5.5s %(name)-20.20s %(levelname)-7.7s %(message)s', + datefmt='%H:%M', + level=logging.INFO +) + +from madminer import sampling +from madminer.sampling import SampleAugmenter +from madminer.fisherinformation import FisherInformation +from madminer.ml import ScoreEstimator + +sampler = SampleAugmenter('data/madminer_example_systematics_with_data.h5') + +x, theta0, theta1, y, r_xz, t_xz, n_effective_samples = sampler.sample_train_ratio( + theta0=sampling.random_morphing_points(None, [('gaussian', 0., 15.), ('gaussian', 0., 15.)]), + theta1=sampling.benchmark('sm'), + nu0=sampling.iid_nuisance_parameters(), + nu1=sampling.nominal_nuisance_parameters(), + n_samples=10000, +) + +logging.info("x: %s", x) diff --git a/examples/tutorial_toy_simulator/tutorial_toy_simulator.ipynb b/examples/tutorial_toy_simulator/tutorial_toy_simulator.ipynb index 2122e37c3..7551c5a3e 100644 --- a/examples/tutorial_toy_simulator/tutorial_toy_simulator.ipynb +++ b/examples/tutorial_toy_simulator/tutorial_toy_simulator.ipynb @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -41,12 +41,12 @@ "from matplotlib import pyplot as plt\n", "%matplotlib inline\n", "\n", - "from madminer.ml import MLForge" + "from madminer.ml import LikelihoodEstimator, ParameterizedRatioEstimator" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -102,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -119,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -153,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -172,7 +172,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -186,7 +186,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -236,7 +236,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -255,7 +255,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -275,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -294,18 +294,6 @@ "np.save('data/t_xz_train.npy', t_xz_train)" ] }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [], - "source": [ - "# For flow training\n", - "np.save('data/theta0_train_density.npy', theta0.reshape(-1,1))\n", - "np.save('data/x_train_density.npy', x_from_theta0.reshape(-1,1))\n", - "np.save('data/t_xz_train_density.npy', t_xz_from_theta0.reshape(-1,1))" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -329,281 +317,293 @@ "name": "stderr", "output_type": "stream", "text": [ - "17:37 madminer.ml INFO Starting training\n", - "17:37 madminer.ml INFO Method: carl\n", - "17:37 madminer.ml INFO Training data: x at data/x_train.npy\n", - "17:37 madminer.ml INFO theta0 at data/theta0_train.npy\n", - "17:37 madminer.ml INFO y at data/y_train.npy\n", - "17:37 madminer.ml INFO Features: all\n", - "17:37 madminer.ml INFO Method: carl\n", - "17:37 madminer.ml INFO Hidden layers: (20, 20)\n", - "17:37 madminer.ml INFO Activation function: tanh\n", - "17:37 madminer.ml INFO Batch size: 200\n", - "17:37 madminer.ml INFO Optimizer: amsgrad\n", - "17:37 madminer.ml INFO Epochs: 20\n", - "17:37 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "17:37 madminer.ml INFO Validation split: 0.25\n", - "17:37 madminer.ml INFO Early stopping: True\n", - "17:37 madminer.ml INFO Scale inputs: True\n", - "17:37 madminer.ml INFO Shuffle labels False\n", - "17:37 madminer.ml INFO Samples: all\n", - "17:37 madminer.ml INFO Loading training data\n", - "17:37 madminer.ml INFO Found 100000 samples with 1 parameters and 1 observables\n", - "17:37 madminer.ml INFO Rescaling inputs\n", - "17:37 madminer.ml INFO Creating model for method carl\n", - "17:37 madminer.ml INFO Training model\n", - "17:37 madminer.utils.ml.tr INFO Epoch 1: train loss 0.63091 (xe: 0.631)\n", - "17:37 madminer.utils.ml.tr INFO val. loss 0.59211 (xe: 0.592)\n", - "17:37 madminer.utils.ml.tr INFO Epoch 2: train loss 0.59132 (xe: 0.591)\n", - "17:37 madminer.utils.ml.tr INFO val. loss 0.58826 (xe: 0.588)\n", - "17:37 madminer.utils.ml.tr INFO Epoch 3: train loss 0.58932 (xe: 0.589)\n", - "17:37 madminer.utils.ml.tr INFO val. loss 0.58768 (xe: 0.588)\n", - "17:38 madminer.utils.ml.tr INFO Epoch 4: train loss 0.58851 (xe: 0.589)\n", - "17:38 madminer.utils.ml.tr INFO val. loss 0.58663 (xe: 0.587)\n", - "17:38 madminer.utils.ml.tr INFO Epoch 5: train loss 0.58779 (xe: 0.588)\n", - "17:38 madminer.utils.ml.tr INFO val. loss 0.58573 (xe: 0.586)\n", - "17:38 madminer.utils.ml.tr INFO Epoch 6: train loss 0.58742 (xe: 0.587)\n", - "17:38 madminer.utils.ml.tr INFO val. loss 0.58609 (xe: 0.586)\n", - "17:38 madminer.utils.ml.tr INFO Epoch 7: train loss 0.58707 (xe: 0.587)\n", - "17:38 madminer.utils.ml.tr INFO val. loss 0.58517 (xe: 0.585)\n", - "17:38 madminer.utils.ml.tr INFO Epoch 8: train loss 0.58683 (xe: 0.587)\n", - "17:38 madminer.utils.ml.tr INFO val. loss 0.58653 (xe: 0.587)\n", - "17:39 madminer.utils.ml.tr INFO Epoch 9: train loss 0.58645 (xe: 0.586)\n", - "17:39 madminer.utils.ml.tr INFO val. loss 0.58496 (xe: 0.585)\n", - "17:39 madminer.utils.ml.tr INFO Epoch 10: train loss 0.58649 (xe: 0.586)\n", - "17:39 madminer.utils.ml.tr INFO val. loss 0.58473 (xe: 0.585)\n", - "17:39 madminer.utils.ml.tr INFO Epoch 11: train loss 0.58621 (xe: 0.586)\n", - "17:39 madminer.utils.ml.tr INFO val. loss 0.58466 (xe: 0.585)\n", - "17:39 madminer.utils.ml.tr INFO Epoch 12: train loss 0.58616 (xe: 0.586)\n", - "17:39 madminer.utils.ml.tr INFO val. loss 0.58450 (xe: 0.585)\n", - "17:39 madminer.utils.ml.tr INFO Epoch 13: train loss 0.58597 (xe: 0.586)\n", - "17:39 madminer.utils.ml.tr INFO val. loss 0.58468 (xe: 0.585)\n", - "17:40 madminer.utils.ml.tr INFO Epoch 14: train loss 0.58593 (xe: 0.586)\n", - "17:40 madminer.utils.ml.tr INFO val. loss 0.58440 (xe: 0.584)\n", - "17:40 madminer.utils.ml.tr INFO Epoch 15: train loss 0.58588 (xe: 0.586)\n", - "17:40 madminer.utils.ml.tr INFO val. loss 0.58429 (xe: 0.584)\n", - "17:40 madminer.utils.ml.tr INFO Epoch 16: train loss 0.58582 (xe: 0.586)\n", - "17:40 madminer.utils.ml.tr INFO val. loss 0.58439 (xe: 0.584)\n", - "17:40 madminer.utils.ml.tr INFO Epoch 17: train loss 0.58574 (xe: 0.586)\n", - "17:40 madminer.utils.ml.tr INFO val. loss 0.58460 (xe: 0.585)\n", - "17:40 madminer.utils.ml.tr INFO Epoch 18: train loss 0.58579 (xe: 0.586)\n", - "17:40 madminer.utils.ml.tr INFO val. loss 0.58431 (xe: 0.584)\n", - "17:40 madminer.utils.ml.tr INFO Epoch 19: train loss 0.58572 (xe: 0.586)\n", - "17:40 madminer.utils.ml.tr INFO val. loss 0.58421 (xe: 0.584)\n", - "17:41 madminer.utils.ml.tr INFO Epoch 20: train loss 0.58567 (xe: 0.586)\n", - "17:41 madminer.utils.ml.tr INFO val. loss 0.58421 (xe: 0.584)\n", - "17:41 madminer.utils.ml.tr INFO Early stopping did not improve performance\n" + "11:26 madminer.ml INFO Starting training\n", + "11:26 madminer.ml INFO Method: carl\n", + "11:26 madminer.ml INFO Batch size: 200\n", + "11:26 madminer.ml INFO Optimizer: amsgrad\n", + "11:26 madminer.ml INFO Epochs: 20\n", + "11:26 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", + "11:26 madminer.ml INFO Validation split: 0.25\n", + "11:26 madminer.ml INFO Early stopping: True\n", + "11:26 madminer.ml INFO Scale inputs: True\n", + "11:26 madminer.ml INFO Shuffle labels False\n", + "11:26 madminer.ml INFO Samples: all\n", + "11:26 madminer.ml INFO Loading training data\n", + "11:26 madminer.ml INFO Found 100000 samples with 1 parameters and 1 observables\n", + "11:26 madminer.ml INFO Rescaling inputs\n", + "11:26 madminer.ml INFO Creating model\n", + "11:26 madminer.ml INFO Training model\n", + "11:27 madminer.utils.ml.tr INFO Epoch 1: train loss 0.63546 (xe: 0.635)\n", + "11:27 madminer.utils.ml.tr INFO val. loss 0.59570 (xe: 0.596)\n", + "11:27 madminer.utils.ml.tr INFO Epoch 2: train loss 0.59274 (xe: 0.593)\n", + "11:27 madminer.utils.ml.tr INFO val. loss 0.59289 (xe: 0.593)\n", + "11:27 madminer.utils.ml.tr INFO Epoch 3: train loss 0.59106 (xe: 0.591)\n", + "11:27 madminer.utils.ml.tr INFO val. loss 0.59155 (xe: 0.592)\n", + "11:27 madminer.utils.ml.tr INFO Epoch 4: train loss 0.58970 (xe: 0.590)\n", + "11:27 madminer.utils.ml.tr INFO val. loss 0.59107 (xe: 0.591)\n", + "11:27 madminer.utils.ml.tr INFO Epoch 5: train loss 0.58887 (xe: 0.589)\n", + "11:27 madminer.utils.ml.tr INFO val. loss 0.59029 (xe: 0.590)\n", + "11:27 madminer.utils.ml.tr INFO Epoch 6: train loss 0.58854 (xe: 0.589)\n", + "11:27 madminer.utils.ml.tr INFO val. loss 0.59009 (xe: 0.590)\n", + "11:27 madminer.utils.ml.tr INFO Epoch 7: train loss 0.58803 (xe: 0.588)\n", + "11:27 madminer.utils.ml.tr INFO val. loss 0.59006 (xe: 0.590)\n", + "11:27 madminer.utils.ml.tr INFO Epoch 8: train loss 0.58782 (xe: 0.588)\n", + "11:27 madminer.utils.ml.tr INFO val. loss 0.58939 (xe: 0.589)\n", + "11:28 madminer.utils.ml.tr INFO Epoch 9: train loss 0.58747 (xe: 0.587)\n", + "11:28 madminer.utils.ml.tr INFO val. loss 0.58919 (xe: 0.589)\n", + "11:28 madminer.utils.ml.tr INFO Epoch 10: train loss 0.58730 (xe: 0.587)\n", + "11:28 madminer.utils.ml.tr INFO val. loss 0.58897 (xe: 0.589)\n", + "11:28 madminer.utils.ml.tr INFO Epoch 11: train loss 0.58727 (xe: 0.587)\n", + "11:28 madminer.utils.ml.tr INFO val. loss 0.58894 (xe: 0.589)\n", + "11:28 madminer.utils.ml.tr INFO Epoch 12: train loss 0.58705 (xe: 0.587)\n", + "11:28 madminer.utils.ml.tr INFO val. loss 0.58877 (xe: 0.589)\n", + "11:28 madminer.utils.ml.tr INFO Epoch 13: train loss 0.58688 (xe: 0.587)\n", + "11:28 madminer.utils.ml.tr INFO val. loss 0.58873 (xe: 0.589)\n", + "11:28 madminer.utils.ml.tr INFO Epoch 14: train loss 0.58687 (xe: 0.587)\n", + "11:28 madminer.utils.ml.tr INFO val. loss 0.58925 (xe: 0.589)\n", + "11:28 madminer.utils.ml.tr INFO Epoch 15: train loss 0.58659 (xe: 0.587)\n", + "11:28 madminer.utils.ml.tr INFO val. loss 0.58855 (xe: 0.589)\n", + "11:29 madminer.utils.ml.tr INFO Epoch 16: train loss 0.58669 (xe: 0.587)\n", + "11:29 madminer.utils.ml.tr INFO val. loss 0.58853 (xe: 0.589)\n", + "11:29 madminer.utils.ml.tr INFO Epoch 17: train loss 0.58662 (xe: 0.587)\n", + "11:29 madminer.utils.ml.tr INFO val. loss 0.58847 (xe: 0.588)\n", + "11:29 madminer.utils.ml.tr INFO Epoch 18: train loss 0.58656 (xe: 0.587)\n", + "11:29 madminer.utils.ml.tr INFO val. loss 0.58849 (xe: 0.588)\n", + "11:29 madminer.utils.ml.tr INFO Epoch 19: train loss 0.58652 (xe: 0.587)\n", + "11:29 madminer.utils.ml.tr INFO val. loss 0.58845 (xe: 0.588)\n", + "11:29 madminer.utils.ml.tr INFO Epoch 20: train loss 0.58646 (xe: 0.586)\n", + "11:29 madminer.utils.ml.tr INFO val. loss 0.58843 (xe: 0.588)\n", + "11:29 madminer.utils.ml.tr INFO Early stopping did not improve performance\n" ] } ], "source": [ - "forge = MLForge()\n", + "carl = ParameterizedRatioEstimator(\n", + " n_hidden=(20,20)\n", + ")\n", "\n", - "forge.train(\n", + "carl.train(\n", " method='carl',\n", - " x_filename='data/x_train.npy',\n", - " y_filename='data/y_train.npy',\n", - " theta0_filename='data/theta0_train.npy',\n", + " x='data/x_train.npy',\n", + " y='data/y_train.npy',\n", + " theta='data/theta0_train.npy',\n", " n_epochs=20,\n", - " n_hidden=(20,20),\n", ")\n", "\n", - "forge.save('models/carl')" + "carl.save('models/carl')" ] }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "11:02 madminer.ml INFO Starting training\n", - "11:02 madminer.ml INFO Method: alices\n", - "11:02 madminer.ml INFO Training data: x at data/x_train.npy\n", - "11:02 madminer.ml INFO theta0 at data/theta0_train.npy\n", - "11:02 madminer.ml INFO y at data/y_train.npy\n", - "11:02 madminer.ml INFO r_xz at data/r_xz_train.npy\n", - "11:02 madminer.ml INFO t_xz (theta0) at data/t_xz_train.npy\n", - "11:02 madminer.ml INFO Features: all\n", - "11:02 madminer.ml INFO Method: alices\n", - "11:02 madminer.ml INFO Hidden layers: (20, 20)\n", - "11:02 madminer.ml INFO Activation function: tanh\n", - "11:02 madminer.ml INFO alpha: 0.1\n", - "11:02 madminer.ml INFO Batch size: 200\n", - "11:02 madminer.ml INFO Optimizer: amsgrad\n", - "11:02 madminer.ml INFO Epochs: 20\n", - "11:02 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "11:02 madminer.ml INFO Validation split: 0.25\n", - "11:02 madminer.ml INFO Early stopping: True\n", - "11:02 madminer.ml INFO Scale inputs: True\n", - "11:02 madminer.ml INFO Shuffle labels False\n", - "11:02 madminer.ml INFO Samples: all\n", - "11:02 madminer.ml INFO Loading training data\n", - "11:02 madminer.ml INFO Found 100000 samples with 1 parameters and 1 observables\n", - "11:02 madminer.ml INFO Rescaling inputs\n", - "11:02 madminer.ml INFO Creating model for method alices\n", - "11:02 madminer.ml INFO Training model\n", - "11:02 madminer.utils.ml.tr INFO Epoch 1: train loss 0.63722 (improved_xe: 0.628, mse_score: 0.088)\n", - "11:02 madminer.utils.ml.tr INFO val. loss 0.59300 (improved_xe: 0.590, mse_score: 0.034)\n", - "11:02 madminer.utils.ml.tr INFO Epoch 2: train loss 0.59024 (improved_xe: 0.588, mse_score: 0.025)\n", - "11:02 madminer.utils.ml.tr INFO val. loss 0.58816 (improved_xe: 0.586, mse_score: 0.017)\n", - "11:03 madminer.utils.ml.tr INFO Epoch 3: train loss 0.58742 (improved_xe: 0.586, mse_score: 0.015)\n", - "11:03 madminer.utils.ml.tr INFO val. loss 0.58671 (improved_xe: 0.586, mse_score: 0.012)\n", - "11:03 madminer.utils.ml.tr INFO Epoch 4: train loss 0.58656 (improved_xe: 0.585, mse_score: 0.011)\n", - "11:03 madminer.utils.ml.tr INFO val. loss 0.58610 (improved_xe: 0.585, mse_score: 0.009)\n", - "11:03 madminer.utils.ml.tr INFO Epoch 5: train loss 0.58618 (improved_xe: 0.585, mse_score: 0.010)\n", - "11:03 madminer.utils.ml.tr INFO val. loss 0.58585 (improved_xe: 0.585, mse_score: 0.008)\n", - "11:03 madminer.utils.ml.tr INFO Epoch 6: train loss 0.58599 (improved_xe: 0.585, mse_score: 0.009)\n", - "11:03 madminer.utils.ml.tr INFO val. loss 0.58575 (improved_xe: 0.585, mse_score: 0.008)\n", - "11:03 madminer.utils.ml.tr INFO Epoch 7: train loss 0.58586 (improved_xe: 0.585, mse_score: 0.008)\n", - "11:03 madminer.utils.ml.tr INFO val. loss 0.58574 (improved_xe: 0.585, mse_score: 0.007)\n", - "11:03 madminer.utils.ml.tr INFO Epoch 8: train loss 0.58579 (improved_xe: 0.585, mse_score: 0.007)\n", - "11:03 madminer.utils.ml.tr INFO val. loss 0.58554 (improved_xe: 0.585, mse_score: 0.007)\n", - "11:03 madminer.utils.ml.tr INFO Epoch 9: train loss 0.58570 (improved_xe: 0.585, mse_score: 0.007)\n", - "11:03 madminer.utils.ml.tr INFO val. loss 0.58557 (improved_xe: 0.585, mse_score: 0.007)\n", - "11:04 madminer.utils.ml.tr INFO Epoch 10: train loss 0.58565 (improved_xe: 0.585, mse_score: 0.007)\n", - "11:04 madminer.utils.ml.tr INFO val. loss 0.58558 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:04 madminer.utils.ml.tr INFO Epoch 11: train loss 0.58560 (improved_xe: 0.585, mse_score: 0.007)\n", - "11:04 madminer.utils.ml.tr INFO val. loss 0.58543 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:04 madminer.utils.ml.tr INFO Epoch 12: train loss 0.58557 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:04 madminer.utils.ml.tr INFO val. loss 0.58547 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:04 madminer.utils.ml.tr INFO Epoch 13: train loss 0.58555 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:04 madminer.utils.ml.tr INFO val. loss 0.58547 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:04 madminer.utils.ml.tr INFO Epoch 14: train loss 0.58552 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:04 madminer.utils.ml.tr INFO val. loss 0.58541 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:04 madminer.utils.ml.tr INFO Epoch 15: train loss 0.58549 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:04 madminer.utils.ml.tr INFO val. loss 0.58536 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:04 madminer.utils.ml.tr INFO Epoch 16: train loss 0.58549 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:04 madminer.utils.ml.tr INFO val. loss 0.58541 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:05 madminer.utils.ml.tr INFO Epoch 17: train loss 0.58547 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:05 madminer.utils.ml.tr INFO val. loss 0.58535 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:05 madminer.utils.ml.tr INFO Epoch 18: train loss 0.58546 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:05 madminer.utils.ml.tr INFO val. loss 0.58534 (improved_xe: 0.585, mse_score: 0.005)\n", - "11:05 madminer.utils.ml.tr INFO Epoch 19: train loss 0.58546 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:05 madminer.utils.ml.tr INFO val. loss 0.58534 (improved_xe: 0.585, mse_score: 0.005)\n", - "11:05 madminer.utils.ml.tr INFO Epoch 20: train loss 0.58544 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:05 madminer.utils.ml.tr INFO val. loss 0.58532 (improved_xe: 0.585, mse_score: 0.006)\n", - "11:05 madminer.utils.ml.tr INFO Early stopping did not improve performance\n" + "11:29 madminer.ml INFO Starting training\n", + "11:29 madminer.ml INFO Method: alices\n", + "11:29 madminer.ml INFO alpha: 0.1\n", + "11:29 madminer.ml INFO Batch size: 200\n", + "11:29 madminer.ml INFO Optimizer: amsgrad\n", + "11:29 madminer.ml INFO Epochs: 20\n", + "11:29 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", + "11:29 madminer.ml INFO Validation split: 0.25\n", + "11:29 madminer.ml INFO Early stopping: True\n", + "11:29 madminer.ml INFO Scale inputs: True\n", + "11:29 madminer.ml INFO Shuffle labels False\n", + "11:29 madminer.ml INFO Samples: all\n", + "11:29 madminer.ml INFO Loading training data\n", + "11:29 madminer.ml INFO Found 100000 samples with 1 parameters and 1 observables\n", + "11:29 madminer.ml INFO Rescaling inputs\n", + "11:29 madminer.ml INFO Creating model\n", + "11:29 madminer.ml INFO Training model\n", + "11:29 madminer.utils.ml.tr INFO Epoch 1: train loss 0.62598 (improved_xe: 0.619, mse_score: 0.074)\n", + "11:29 madminer.utils.ml.tr INFO val. loss 0.59175 (improved_xe: 0.589, mse_score: 0.031)\n", + "11:29 madminer.utils.ml.tr INFO Epoch 2: train loss 0.58943 (improved_xe: 0.587, mse_score: 0.021)\n", + "11:29 madminer.utils.ml.tr INFO val. loss 0.58757 (improved_xe: 0.586, mse_score: 0.017)\n", + "11:29 madminer.utils.ml.tr INFO Epoch 3: train loss 0.58713 (improved_xe: 0.586, mse_score: 0.013)\n", + "11:29 madminer.utils.ml.tr INFO val. loss 0.58621 (improved_xe: 0.585, mse_score: 0.012)\n", + "11:30 madminer.utils.ml.tr INFO Epoch 4: train loss 0.58627 (improved_xe: 0.585, mse_score: 0.010)\n", + "11:30 madminer.utils.ml.tr INFO val. loss 0.58559 (improved_xe: 0.585, mse_score: 0.010)\n", + "11:30 madminer.utils.ml.tr INFO Epoch 5: train loss 0.58587 (improved_xe: 0.585, mse_score: 0.008)\n", + "11:30 madminer.utils.ml.tr INFO val. loss 0.58530 (improved_xe: 0.584, mse_score: 0.009)\n", + "11:30 madminer.utils.ml.tr INFO Epoch 6: train loss 0.58563 (improved_xe: 0.585, mse_score: 0.007)\n", + "11:30 madminer.utils.ml.tr INFO val. loss 0.58508 (improved_xe: 0.584, mse_score: 0.007)\n", + "11:30 madminer.utils.ml.tr INFO Epoch 7: train loss 0.58547 (improved_xe: 0.585, mse_score: 0.007)\n", + "11:30 madminer.utils.ml.tr INFO val. loss 0.58504 (improved_xe: 0.584, mse_score: 0.007)\n", + "11:30 madminer.utils.ml.tr INFO Epoch 8: train loss 0.58538 (improved_xe: 0.585, mse_score: 0.006)\n", + "11:30 madminer.utils.ml.tr INFO val. loss 0.58491 (improved_xe: 0.584, mse_score: 0.007)\n", + "11:30 madminer.utils.ml.tr INFO Epoch 9: train loss 0.58531 (improved_xe: 0.585, mse_score: 0.006)\n", + "11:30 madminer.utils.ml.tr INFO val. loss 0.58486 (improved_xe: 0.584, mse_score: 0.006)\n", + "11:31 madminer.utils.ml.tr INFO Epoch 10: train loss 0.58526 (improved_xe: 0.585, mse_score: 0.006)\n", + "11:31 madminer.utils.ml.tr INFO val. loss 0.58481 (improved_xe: 0.584, mse_score: 0.006)\n", + "11:31 madminer.utils.ml.tr INFO Epoch 11: train loss 0.58522 (improved_xe: 0.585, mse_score: 0.006)\n", + "11:31 madminer.utils.ml.tr INFO val. loss 0.58477 (improved_xe: 0.584, mse_score: 0.006)\n", + "11:31 madminer.utils.ml.tr INFO Epoch 12: train loss 0.58518 (improved_xe: 0.585, mse_score: 0.005)\n", + "11:31 madminer.utils.ml.tr INFO val. loss 0.58482 (improved_xe: 0.584, mse_score: 0.006)\n", + "11:31 madminer.utils.ml.tr INFO Epoch 13: train loss 0.58516 (improved_xe: 0.585, mse_score: 0.005)\n", + "11:31 madminer.utils.ml.tr INFO val. loss 0.58481 (improved_xe: 0.584, mse_score: 0.006)\n", + "11:31 madminer.utils.ml.tr INFO Epoch 14: train loss 0.58513 (improved_xe: 0.585, mse_score: 0.005)\n", + "11:31 madminer.utils.ml.tr INFO val. loss 0.58472 (improved_xe: 0.584, mse_score: 0.006)\n", + "11:31 madminer.utils.ml.tr INFO Epoch 15: train loss 0.58512 (improved_xe: 0.585, mse_score: 0.005)\n", + "11:31 madminer.utils.ml.tr INFO val. loss 0.58473 (improved_xe: 0.584, mse_score: 0.006)\n", + "11:32 madminer.utils.ml.tr INFO Epoch 16: train loss 0.58511 (improved_xe: 0.585, mse_score: 0.005)\n", + "11:32 madminer.utils.ml.tr INFO val. loss 0.58472 (improved_xe: 0.584, mse_score: 0.006)\n", + "11:32 madminer.utils.ml.tr INFO Epoch 17: train loss 0.58509 (improved_xe: 0.585, mse_score: 0.005)\n", + "11:32 madminer.utils.ml.tr INFO val. loss 0.58466 (improved_xe: 0.584, mse_score: 0.006)\n", + "11:32 madminer.utils.ml.tr INFO Epoch 18: train loss 0.58508 (improved_xe: 0.585, mse_score: 0.005)\n", + "11:32 madminer.utils.ml.tr INFO val. loss 0.58468 (improved_xe: 0.584, mse_score: 0.006)\n", + "11:32 madminer.utils.ml.tr INFO Epoch 19: train loss 0.58507 (improved_xe: 0.585, mse_score: 0.005)\n", + "11:32 madminer.utils.ml.tr INFO val. loss 0.58474 (improved_xe: 0.584, mse_score: 0.005)\n", + "11:32 madminer.utils.ml.tr INFO Epoch 20: train loss 0.58506 (improved_xe: 0.585, mse_score: 0.005)\n", + "11:32 madminer.utils.ml.tr INFO val. loss 0.58464 (improved_xe: 0.584, mse_score: 0.006)\n", + "11:32 madminer.utils.ml.tr INFO Early stopping did not improve performance\n" ] } ], "source": [ - "forge = MLForge()\n", + "alices = ParameterizedRatioEstimator(\n", + " n_hidden=(20,20)\n", + ")\n", "\n", - "forge.train(\n", + "alices.train(\n", " method='alices',\n", - " x_filename='data/x_train.npy',\n", - " y_filename='data/y_train.npy',\n", - " theta0_filename='data/theta0_train.npy',\n", - " r_xz_filename='data/r_xz_train.npy',\n", - " t_xz0_filename='data/t_xz_train.npy',\n", + " x='data/x_train.npy',\n", + " y='data/y_train.npy',\n", + " theta='data/theta0_train.npy',\n", + " r_xz='data/r_xz_train.npy',\n", + " t_xz='data/t_xz_train.npy',\n", " alpha=0.1,\n", " n_epochs=20,\n", - " n_hidden=(20,20),\n", ")\n", "\n", - "forge.save('models/alices')" + "alices.save('models/alices')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also try a little bit of mixing and matching -- let's train a model with CARL first and then with ALICES:" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "11:05 madminer.ml INFO Starting training\n", - "11:05 madminer.ml INFO Method: scandal\n", - "11:05 madminer.ml INFO Training data: x at data/x_train_density.npy\n", - "11:05 madminer.ml INFO theta0 at data/theta0_train_density.npy\n", - "11:05 madminer.ml INFO t_xz (theta0) at data/t_xz_train_density.npy\n", - "11:05 madminer.ml INFO Features: all\n", - "11:05 madminer.ml INFO Method: scandal\n", - "11:05 madminer.ml INFO Neural density est.: maf\n", - "11:05 madminer.ml INFO MAF, number MADEs: 3\n", - "11:05 madminer.ml INFO MAF, batch norm: False\n", - "11:05 madminer.ml INFO MAF, BN alpha: 0.1\n", - "11:05 madminer.ml INFO MAF MoG, components: 10\n", - "11:05 madminer.ml INFO Activation function: tanh\n", - "11:05 madminer.ml INFO alpha: 50.0\n", - "11:05 madminer.ml INFO Batch size: 200\n", - "11:05 madminer.ml INFO Optimizer: amsgrad\n", - "11:05 madminer.ml INFO Epochs: 20\n", - "11:05 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0001\n", - "11:05 madminer.ml INFO Validation split: 0.25\n", - "11:05 madminer.ml INFO Early stopping: True\n", - "11:05 madminer.ml INFO Scale inputs: True\n", - "11:05 madminer.ml INFO Shuffle labels False\n", - "11:05 madminer.ml INFO Samples: all\n", - "11:05 madminer.ml INFO Loading training data\n", - "11:05 madminer.ml INFO Found 50000 samples with 1 parameters and 1 observables\n", - "11:05 madminer.ml INFO Rescaling inputs\n", - "11:05 madminer.ml INFO Creating model for method scandal\n", - "11:05 madminer.ml INFO Training model\n", - "11:05 madminer.utils.ml.tr INFO Epoch 1: train loss 4.34533 (nll: 1.124, mse_score: 0.064)\n", - "11:05 madminer.utils.ml.tr INFO val. loss 1.18938 (nll: 1.064, mse_score: 0.003)\n", - "11:05 madminer.utils.ml.tr INFO Epoch 2: train loss 1.14191 (nll: 1.071, mse_score: 0.001)\n", - "11:05 madminer.utils.ml.tr INFO val. loss 1.10522 (nll: 1.067, mse_score: 0.001)\n", - "11:05 madminer.utils.ml.tr INFO Epoch 3: train loss 1.09866 (nll: 1.072, mse_score: 0.001)\n", - "11:05 madminer.utils.ml.tr INFO val. loss 1.08518 (nll: 1.068, mse_score: 0.000)\n", - "11:05 madminer.utils.ml.tr INFO Epoch 4: train loss 1.08538 (nll: 1.072, mse_score: 0.000)\n", - "11:05 madminer.utils.ml.tr INFO val. loss 1.07815 (nll: 1.066, mse_score: 0.000)\n", - "11:05 madminer.utils.ml.tr INFO Epoch 5: train loss 1.08161 (nll: 1.071, mse_score: 0.000)\n", - "11:05 madminer.utils.ml.tr INFO val. loss 1.07443 (nll: 1.066, mse_score: 0.000)\n", - "11:05 madminer.utils.ml.tr INFO Epoch 6: train loss 1.07892 (nll: 1.071, mse_score: 0.000)\n", - "11:05 madminer.utils.ml.tr INFO val. loss 1.07287 (nll: 1.066, mse_score: 0.000)\n", - "11:05 madminer.utils.ml.tr INFO Epoch 7: train loss 1.07803 (nll: 1.071, mse_score: 0.000)\n", - "11:05 madminer.utils.ml.tr INFO val. loss 1.07254 (nll: 1.066, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Epoch 8: train loss 1.07773 (nll: 1.072, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO val. loss 1.07069 (nll: 1.065, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Epoch 9: train loss 1.07675 (nll: 1.072, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO val. loss 1.07098 (nll: 1.067, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Epoch 10: train loss 1.07594 (nll: 1.071, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO val. loss 1.07090 (nll: 1.067, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Epoch 11: train loss 1.07572 (nll: 1.071, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO val. loss 1.06878 (nll: 1.065, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Epoch 12: train loss 1.07565 (nll: 1.072, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO val. loss 1.06987 (nll: 1.066, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Epoch 13: train loss 1.07490 (nll: 1.071, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO val. loss 1.06968 (nll: 1.066, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Epoch 14: train loss 1.07507 (nll: 1.072, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO val. loss 1.07054 (nll: 1.067, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Epoch 15: train loss 1.07418 (nll: 1.071, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO val. loss 1.06996 (nll: 1.067, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Epoch 16: train loss 1.07446 (nll: 1.071, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO val. loss 1.06844 (nll: 1.065, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Epoch 17: train loss 1.07460 (nll: 1.072, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO val. loss 1.06835 (nll: 1.066, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Epoch 18: train loss 1.07443 (nll: 1.071, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO val. loss 1.06960 (nll: 1.067, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Epoch 19: train loss 1.07422 (nll: 1.071, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO val. loss 1.06920 (nll: 1.067, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Epoch 20: train loss 1.07374 (nll: 1.071, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO val. loss 1.06874 (nll: 1.066, mse_score: 0.000)\n", - "11:06 madminer.utils.ml.tr INFO Early stopping did not improve performance\n" + "11:47 madminer.ml INFO Starting training\n", + "11:47 madminer.ml INFO Method: carl\n", + "11:47 madminer.ml INFO Batch size: 200\n", + "11:47 madminer.ml INFO Optimizer: amsgrad\n", + "11:47 madminer.ml INFO Epochs: 10\n", + "11:47 madminer.ml INFO Learning rate: 0.001 initially, decaying to 0.0003\n", + "11:47 madminer.ml INFO Validation split: 0.25\n", + "11:47 madminer.ml INFO Early stopping: True\n", + "11:47 madminer.ml INFO Scale inputs: True\n", + "11:47 madminer.ml INFO Shuffle labels False\n", + "11:47 madminer.ml INFO Samples: all\n", + "11:47 madminer.ml INFO Loading training data\n", + "11:47 madminer.ml INFO Found 100000 samples with 1 parameters and 1 observables\n", + "11:47 madminer.ml INFO Rescaling inputs\n", + "11:47 madminer.ml INFO Creating model\n", + "11:47 madminer.ml INFO Training model\n", + "11:47 madminer.utils.ml.tr INFO Epoch 1: train loss 0.63224 (xe: 0.632)\n", + "11:47 madminer.utils.ml.tr INFO val. loss 0.59488 (xe: 0.595)\n", + "11:47 madminer.utils.ml.tr INFO Epoch 2: train loss 0.59448 (xe: 0.594)\n", + "11:47 madminer.utils.ml.tr INFO val. loss 0.59229 (xe: 0.592)\n", + "11:47 madminer.utils.ml.tr INFO Epoch 3: train loss 0.59231 (xe: 0.592)\n", + "11:47 madminer.utils.ml.tr INFO val. loss 0.59073 (xe: 0.591)\n", + "11:48 madminer.utils.ml.tr INFO Epoch 4: train loss 0.59127 (xe: 0.591)\n", + "11:48 madminer.utils.ml.tr INFO val. loss 0.59010 (xe: 0.590)\n", + "11:48 madminer.utils.ml.tr INFO Epoch 5: train loss 0.59012 (xe: 0.590)\n", + "11:48 madminer.utils.ml.tr INFO val. loss 0.58883 (xe: 0.589)\n", + "11:48 madminer.utils.ml.tr INFO Epoch 6: train loss 0.58952 (xe: 0.590)\n", + "11:48 madminer.utils.ml.tr INFO val. loss 0.58939 (xe: 0.589)\n", + "11:48 madminer.utils.ml.tr INFO Epoch 7: train loss 0.58919 (xe: 0.589)\n", + "11:48 madminer.utils.ml.tr INFO val. loss 0.58817 (xe: 0.588)\n", + "11:48 madminer.utils.ml.tr INFO Epoch 8: train loss 0.58878 (xe: 0.589)\n", + "11:48 madminer.utils.ml.tr INFO val. loss 0.58800 (xe: 0.588)\n", + "11:48 madminer.utils.ml.tr INFO Epoch 9: train loss 0.58860 (xe: 0.589)\n", + "11:48 madminer.utils.ml.tr INFO val. loss 0.58770 (xe: 0.588)\n", + "11:48 madminer.utils.ml.tr INFO Epoch 10: train loss 0.58839 (xe: 0.588)\n", + "11:48 madminer.utils.ml.tr INFO val. loss 0.58745 (xe: 0.587)\n", + "11:48 madminer.utils.ml.tr INFO Early stopping did not improve performance\n", + "11:48 madminer.ml INFO Starting training\n", + "11:48 madminer.ml INFO Method: alices\n", + "11:48 madminer.ml INFO alpha: 0.1\n", + "11:48 madminer.ml INFO Batch size: 200\n", + "11:48 madminer.ml INFO Optimizer: amsgrad\n", + "11:48 madminer.ml INFO Epochs: 10\n", + "11:48 madminer.ml INFO Learning rate: 0.0003 initially, decaying to 0.0001\n", + "11:48 madminer.ml INFO Validation split: 0.25\n", + "11:48 madminer.ml INFO Early stopping: True\n", + "11:48 madminer.ml INFO Scale inputs: True\n", + "11:48 madminer.ml INFO Shuffle labels False\n", + "11:48 madminer.ml INFO Samples: all\n", + "11:48 madminer.ml INFO Loading training data\n", + "11:48 madminer.ml INFO Found 100000 samples with 1 parameters and 1 observables\n", + "11:48 madminer.ml INFO Rescaling inputs\n", + "11:48 madminer.ml INFO Training model\n", + "11:48 madminer.utils.ml.tr INFO Epoch 1: train loss 0.58869 (improved_xe: 0.586, mse_score: 0.024)\n", + "11:48 madminer.utils.ml.tr INFO val. loss 0.58817 (improved_xe: 0.586, mse_score: 0.020)\n", + "11:49 madminer.utils.ml.tr INFO Epoch 2: train loss 0.58764 (improved_xe: 0.586, mse_score: 0.018)\n", + "11:49 madminer.utils.ml.tr INFO val. loss 0.58755 (improved_xe: 0.586, mse_score: 0.016)\n", + "11:49 madminer.utils.ml.tr INFO Epoch 3: train loss 0.58709 (improved_xe: 0.586, mse_score: 0.015)\n", + "11:49 madminer.utils.ml.tr INFO val. loss 0.58707 (improved_xe: 0.586, mse_score: 0.014)\n", + "11:49 madminer.utils.ml.tr INFO Epoch 4: train loss 0.58675 (improved_xe: 0.585, mse_score: 0.014)\n", + "11:49 madminer.utils.ml.tr INFO val. loss 0.58673 (improved_xe: 0.585, mse_score: 0.013)\n", + "11:49 madminer.utils.ml.tr INFO Epoch 5: train loss 0.58650 (improved_xe: 0.585, mse_score: 0.013)\n", + "11:49 madminer.utils.ml.tr INFO val. loss 0.58653 (improved_xe: 0.585, mse_score: 0.012)\n", + "11:49 madminer.utils.ml.tr INFO Epoch 6: train loss 0.58634 (improved_xe: 0.585, mse_score: 0.012)\n", + "11:49 madminer.utils.ml.tr INFO val. loss 0.58642 (improved_xe: 0.585, mse_score: 0.011)\n", + "11:49 madminer.utils.ml.tr INFO Epoch 7: train loss 0.58621 (improved_xe: 0.585, mse_score: 0.011)\n", + "11:49 madminer.utils.ml.tr INFO val. loss 0.58635 (improved_xe: 0.585, mse_score: 0.011)\n", + "11:49 madminer.utils.ml.tr INFO Epoch 8: train loss 0.58610 (improved_xe: 0.585, mse_score: 0.011)\n", + "11:49 madminer.utils.ml.tr INFO val. loss 0.58618 (improved_xe: 0.585, mse_score: 0.011)\n", + "11:49 madminer.utils.ml.tr INFO Epoch 9: train loss 0.58601 (improved_xe: 0.585, mse_score: 0.011)\n", + "11:49 madminer.utils.ml.tr INFO val. loss 0.58612 (improved_xe: 0.585, mse_score: 0.010)\n", + "11:50 madminer.utils.ml.tr INFO Epoch 10: train loss 0.58595 (improved_xe: 0.585, mse_score: 0.010)\n", + "11:50 madminer.utils.ml.tr INFO val. loss 0.58605 (improved_xe: 0.585, mse_score: 0.010)\n", + "11:50 madminer.utils.ml.tr INFO Early stopping did not improve performance\n" ] } ], "source": [ - "forge = MLForge()\n", + "mix = ParameterizedRatioEstimator(\n", + " n_hidden=(20,20)\n", + ")\n", "\n", - "forge.train(\n", - " method='scandal',\n", - " x_filename='data/x_train_density.npy',\n", - " theta0_filename='data/theta0_train_density.npy',\n", - " t_xz0_filename='data/t_xz_train_density.npy',\n", - " alpha=50.,\n", - " n_epochs=20,\n", - " n_hidden=(20,20),\n", - " nde_type=\"maf\"\n", + "mix.train(\n", + " method='carl',\n", + " x='data/x_train.npy',\n", + " y='data/y_train.npy',\n", + " theta='data/theta0_train.npy',\n", + " n_epochs=10,\n", + " initial_lr=0.001,\n", + " final_lr=0.0003,\n", ")\n", "\n", - "forge.save('models/scandal')" + "mix.train(\n", + " method='alices',\n", + " x='data/x_train.npy',\n", + " y='data/y_train.npy',\n", + " theta='data/theta0_train.npy',\n", + " r_xz='data/r_xz_train.npy',\n", + " t_xz='data/t_xz_train.npy',\n", + " alpha=0.1,\n", + " n_epochs=10,\n", + " initial_lr=0.0003,\n", + " final_lr=0.0001,\n", + ")\n", + "\n", + "mix.save('models/mix')" ] }, { @@ -622,7 +622,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -639,7 +639,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -656,13 +656,12 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "theta_grid = np.linspace(-5.,5.,100).reshape(-1, 1)\n", - "np.save('data/theta_grid.npy', theta_grid)\n", - "np.save('data/theta1.npy', np.zeros((1,1)))" + "np.save('data/theta_grid.npy', theta_grid)" ] }, { @@ -674,7 +673,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -701,15 +700,15 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ - "forge = MLForge()\n", - "forge.load('models/carl')\n", + "carl = ParameterizedRatioEstimator()\n", + "carl.load('models/carl')\n", "\n", - "log_r, _, _ = forge.evaluate(\n", - " theta0_filename='data/theta_grid.npy',\n", + "log_r, _ = carl.evaluate(\n", + " theta='data/theta_grid.npy',\n", " x='data/x_test.npy',\n", " evaluate_score=False\n", ")\n", @@ -719,15 +718,15 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ - "forge = MLForge()\n", - "forge.load('models/alices')\n", + "alices = ParameterizedRatioEstimator()\n", + "alices.load('models/alices')\n", "\n", - "log_r, _, _ = forge.evaluate(\n", - " theta0_filename='data/theta_grid.npy',\n", + "log_r, _ = alices.evaluate(\n", + " theta='data/theta_grid.npy',\n", " x='data/x_test.npy',\n", " evaluate_score=False\n", ")\n", @@ -737,26 +736,20 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ - "forge = MLForge()\n", - "forge.load('models/scandal')\n", + "mix = ParameterizedRatioEstimator()\n", + "mix.load('models/mix')\n", "\n", - "log_p0, _ = forge.evaluate(\n", - " theta0_filename='data/theta_grid.npy',\n", - " x='data/x_test.npy',\n", - " evaluate_score=False\n", - ")\n", - "log_p1, _ = forge.evaluate(\n", - " theta0_filename='data/theta1.npy',\n", + "log_r, _ = mix.evaluate(\n", + " theta='data/theta_grid.npy',\n", " x='data/x_test.npy',\n", " evaluate_score=False\n", ")\n", - "log_r = log_p0 - log_p1\n", "\n", - "nllr_test_scandal = -2. * np.mean(log_r, axis=1)" + "nllr_test_mix = -2. * np.mean(log_r, axis=1)" ] }, { @@ -768,12 +761,12 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -787,14 +780,14 @@ "source": [ "best_fit_alices = float(theta_grid[np.argmin(nllr_test_alices)])\n", "best_fit_carl = float(theta_grid[np.argmin(nllr_test_carl)])\n", - "best_fit_scandal = float(theta_grid[np.argmin(nllr_test_scandal)])\n", + "best_fit_mix = float(theta_grid[np.argmin(nllr_test_mix)])\n", "\n", "fig = plt.figure(figsize=(5,5))\n", "\n", - "plt.plot(theta_grid, nllr_test_true, label=r'Ground truth ($\\theta = 1.0$)')\n", - "plt.plot(theta_grid, nllr_test_carl, label=r'CARL ($\\hat{\\theta} = ' + '{:.2f}$)'.format(best_fit_carl))\n", - "plt.plot(theta_grid, nllr_test_alices, label=r'ALICES ($\\hat{\\theta} = ' + '{:.2f}$)'.format(best_fit_alices))\n", - "plt.plot(theta_grid, nllr_test_scandal, label=r'SCANDAL ($\\hat{\\theta} = ' + '{:.2f}$)'.format(best_fit_scandal))\n", + "plt.plot(theta_grid, nllr_test_true, ls='--', c='black', label=r'Ground truth ($\\theta = 1.0$)')\n", + "plt.plot(theta_grid, nllr_test_carl, label=r'CARL ($\\hat{\\theta} = ' + '{:.3f}$)'.format(best_fit_carl))\n", + "plt.plot(theta_grid, nllr_test_alices, label=r'ALICES ($\\hat{\\theta} = ' + '{:.3f}$)'.format(best_fit_alices))\n", + "plt.plot(theta_grid, nllr_test_mix, label=r'CARL-ALICES ($\\hat{\\theta} = ' + '{:.3f}$)'.format(best_fit_mix))\n", "\n", "plt.xlabel(r'$\\theta$')\n", "plt.ylabel(r'$\\mathbb{E}_x [ -2\\, \\log \\,r(x | \\theta, \\theta_{1}) ]$')\n", diff --git a/madminer/__version__.py b/madminer/__version__.py index c49a95c35..493f7415d 100644 --- a/madminer/__version__.py +++ b/madminer/__version__.py @@ -1 +1 @@ -__version__ = "0.2.8" +__version__ = "0.3.0" diff --git a/madminer/analysis.py b/madminer/analysis.py new file mode 100644 index 000000000..018a58dae --- /dev/null +++ b/madminer/analysis.py @@ -0,0 +1,665 @@ +from __future__ import absolute_import, division, print_function, unicode_literals + +import logging +import numpy as np +import six + +from madminer.utils.interfaces.madminer_hdf5 import load_madminer_settings, madminer_event_loader +from madminer.utils.morphing import PhysicsMorpher, NuisanceMorpher +from madminer.utils.various import format_benchmark, mdot + +logger = logging.getLogger(__name__) + + +class DataAnalyzer(object): + """ + Collects common functionality that is used when analysing data in the MadMiner file. + + Parameters + ---------- + filename : str + Path to MadMiner file (for instance the output of `madminer.delphes.DelphesProcessor.save()`). + + disable_morphing : bool, optional + If True, the morphing setup is not loaded from the file. Default value: False. + + include_nuisance_parameters : bool, optional + If True, nuisance parameters are taken into account. Default value: True. + + """ + + def __init__(self, filename, disable_morphing=False, include_nuisance_parameters=True): + # Save setup + self.include_nuisance_parameters = include_nuisance_parameters + self.madminer_filename = filename + + logger.info("Loading data from %s", filename) + + # Load data + ( + self.parameters, + self.benchmarks, + self.benchmark_is_nuisance, + self.morphing_components, + self.morphing_matrix, + self.observables, + self.n_samples, + _, + self.reference_benchmark, + self.nuisance_parameters, + ) = load_madminer_settings(filename, include_nuisance_benchmarks=include_nuisance_parameters) + + self.n_parameters = len(self.parameters) + self.n_benchmarks = len(self.benchmarks) + self.n_benchmarks_phys = np.sum(np.logical_not(self.benchmark_is_nuisance)) + self.n_observables = len(self.observables) + + self.n_nuisance_parameters = 0 + if self.nuisance_parameters is not None and include_nuisance_parameters: + self.n_nuisance_parameters = len(self.nuisance_parameters) + else: + self.nuisance_parameters = None + + logger.info("Found %s parameters", self.n_parameters) + for key, values in six.iteritems(self.parameters): + logger.debug( + " %s (LHA: %s %s, maximal power in squared ME: %s, range: %s)", + key, + values[0], + values[1], + values[2], + values[3], + ) + + if self.nuisance_parameters is not None: + logger.info("Found %s nuisance parameters", self.n_nuisance_parameters) + for key, values in six.iteritems(self.nuisance_parameters): + logger.debug(" %s (%s)", key, values) + else: + logger.info("Did not find nuisance parameters") + + logger.info("Found %s benchmarks, of which %s physical", self.n_benchmarks, self.n_benchmarks_phys) + for (key, values), is_nuisance in zip(six.iteritems(self.benchmarks), self.benchmark_is_nuisance): + if is_nuisance: + logger.debug(" %s: systematics", key) + else: + logger.debug(" %s: %s", key, format_benchmark(values)) + + logger.info("Found %s observables", len(self.observables)) + for i, obs in enumerate(self.observables): + logger.debug(" %2.2s %s", i, obs) + logger.info("Found %s events", self.n_samples) + + # Morphing + self.morpher = None + if self.morphing_matrix is not None and self.morphing_components is not None and not disable_morphing: + self.morpher = PhysicsMorpher(self.parameters) + self.morpher.set_components(self.morphing_components) + self.morpher.set_basis(self.benchmarks, morphing_matrix=self.morphing_matrix) + + logger.info("Found morphing setup with %s components", len(self.morphing_components)) + + else: + logger.info("Did not find morphing setup.") + + # Nuisance morphing + self.nuisance_morpher = None + if self.nuisance_parameters is not None: + self.nuisance_morpher = NuisanceMorpher( + self.nuisance_parameters, list(self.benchmarks.keys()), self.reference_benchmark + ) + logger.info("Found nuisance morphing setup") + + def event_loader(self, start=0, end=None, batch_size=100000, include_nuisance_parameters=None): + if include_nuisance_parameters is None: + include_nuisance_parameters = self.include_nuisance_parameters + for data in madminer_event_loader( + self.madminer_filename, + start, + end, + batch_size, + include_nuisance_parameters, + benchmark_is_nuisance=self.benchmark_is_nuisance, + ): + yield data + + def weighted_events(self, theta=None, nu=None, start_event=None, end_event=None, derivative=False): + """ + Returns all events together with the benchmark weights (if theta is None) or weights for a given theta. + + Parameters + ---------- + theta : None or ndarray or str, optional + If None, the function returns all benchmark weights. If str, the function returns the weights for a given + benchmark name. If ndarray, it uses morphing to calculate the weights for this value of theta. Default + value: None. + + nu : None or ndarray, optional + If None, the nuisance parameters are set to their nominal values. Otherwise, and if theta is an ndarray, + sets the values of the nuisance parameters. + + start_event : int + Index (in the MadMiner file) of the first event to consider. + + end_event : int + Index (in the MadMiner file) of the last unweighted event to consider. + + derivative : bool, optional + If True and if theta is not None, the derivative of the weights with respect to theta are returned. Default + value: False. + + Returns + ------- + x : ndarray + Observables with shape `(n_unweighted_samples, n_observables)`. + + weights : ndarray + If theta is None and derivative is False, benchmark weights with shape + `(n_unweighted_samples, n_benchmarks)` in pb. If theta is not None and derivative is True, the gradient of + the weight for the given parameter with respect to theta with shape `(n_unweighted_samples, n_gradients)` + in pb. Otherwise, weights for the given parameter theta with shape `(n_unweighted_samples,)` in pb. + + """ + + x, weights_benchmarks = next(self.event_loader(batch_size=None, start=start_event, end=end_event)) + + if theta is None: + return x, weights_benchmarks + + elif isinstance(theta, six.string_types): + i_benchmark = list(self.benchmarks.keys()).index(theta) + return x, weights_benchmarks[:, i_benchmark] + + elif derivative: + dtheta_matrix = self._get_dtheta_benchmark_matrix(theta) + + gradients_theta = mdot(dtheta_matrix, weights_benchmarks) # (n_gradients, n_samples) + gradients_theta = gradients_theta.T + + return x, gradients_theta + + else: + # TODO: nuisance params + if nu is not None: + raise NotImplementedError + + theta_matrix = self._get_theta_benchmark_matrix(theta) + weights_theta = mdot(theta_matrix, weights_benchmarks) + + return x, weights_theta + + def xsecs( + self, thetas=None, nus=None, events="all", test_split=0.2, include_nuisance_benchmarks=True, batch_size=100000 + ): + """ + Returns the total cross sections for benchmarks or parameter points. + + Parameters + ---------- + thetas : None or list of (ndarray or str), optional + If None, the function returns all benchmark cross sections. Otherwise, it returns the cross sections for a + series of parameter points that are either given by their benchmark name (as a str), their benchmark index + (as an int), or their parameter value (as an ndarray, using morphing). Default value: None. + + nus : None or list of (None or ndarray), optional + If None, the nuisance parameters are set to their nominal values (0), i.e. no systematics are taken into + account. Otherwise, the list has to have the same number of elements as thetas, and each entry can specify + nuisance parameters at nominal value (None) or a value of the nuisance parameters (ndarray). + + include_nuisance_benchmarks : bool, optional + Whether to include nuisance benchmarks if thetas is None. Default value: True. + + test_split : float, optional + Fraction of events reserved for testing. Default value: 0.2. + + events : {"train", "test", "all"}, optional + Which events to use. Default: "all". + + batch_size : int, optional + Size of the batches of events that are loaded into memory at the same time. Default value: 100000. + + Returns + ------- + xsecs : ndarray + Calculated cross sections in pb. + + xsec_uncertainties : ndarray + Cross-section uncertainties in pb. Basically calculated as sum(weights**2)**0.5. + """ + + logger.debug("Calculating cross sections for thetas = %s and nus = %s", thetas, nus) + + # Inputs + if thetas is not None: + include_nuisance_benchmarks = True + + if thetas is not None: + if nus is None: + nus = [None for _ in thetas] + assert len(nus) == len(thetas), "Numbers of thetas and nus don't match!" + + # Which events to use + if events == "all": + start_event, end_event = None, None + correction_factor = 1.0 + elif events == "train": + start_event, end_event, correction_factor = self._train_test_split(True, test_split) + elif events == "test": + start_event, end_event, correction_factor = self._train_test_split(False, test_split) + else: + raise ValueError("Events has to be either 'all', 'train', or 'test', but got {}!".format(events)) + + # Theta matrices (translation of benchmarks to theta, at nominal nuisance params) + theta_matrices = [self._get_theta_benchmark_matrix(theta) for theta in thetas] + theta_matrices = np.asarray(theta_matrices) # Shape (n_thetas, n_benchmarks) + + # Loop over events + xsecs = 0.0 + xsec_uncertainties = 0.0 + + for i_batch, (_, benchmark_weights) in enumerate( + madminer_event_loader( + self.madminer_filename, + start=start_event, + end=end_event, + include_nuisance_parameters=include_nuisance_benchmarks, + benchmark_is_nuisance=self.benchmark_is_nuisance, + batch_size=batch_size, + ) + ): + n_batch, _ = benchmark_weights.shape + logger.debug("Batch %s with %s events", i_batch + 1, n_batch) + + # Benchmark xsecs + if thetas is None: + xsecs += np.sum(benchmark_weights, axis=0) + xsec_uncertainties += np.sum(benchmark_weights * benchmark_weights, axis=0) + + # xsecs at given parame ters(theta, nu) + else: + # Weights at nominal nuisance params (nu=0) + weights_nom = mdot(theta_matrices, benchmark_weights) # Shape (n_thetas, n_batch) + weights_sq_nom = mdot(theta_matrices, benchmark_weights * benchmark_weights) # same + logger.debug("Nominal weights: %s", weights_nom) + + # Effect of nuisance parameters + nuisance_factors = self._calculate_nuisance_factors(nus, benchmark_weights) + weights = nuisance_factors * weights_nom + weights_sq = nuisance_factors * weights_sq_nom + logger.debug("Nuisance factors: %s", nuisance_factors) + + # Sum up + xsecs += np.sum(weights, axis=1) + xsec_uncertainties += np.sum(weights_sq, axis=1) + + xsec_uncertainties = xsec_uncertainties ** 0.5 + + # Correct for not using all events + xsecs *= correction_factor + xsec_uncertainties *= correction_factor + + logger.debug("xsecs and uncertainties [pb]:") + for this_xsec, this_uncertainty in zip(xsecs, xsec_uncertainties): + logger.debug(" (%4f +/- %4f) pb (%4f %%)", this_xsec, this_uncertainty, 100 * this_uncertainty / this_xsec) + + return xsecs, xsec_uncertainties + + def _calculate_nuisance_factors(self, nus, benchmark_weights): + if self._any_nontrivial_nus(nus): + return np.asarray( + [self.nuisance_morpher.calculate_nuisance_factors(nu, benchmark_weights) for nu in nus] + ) # Shape (n_thetas, n_batch) + else: + return 1.0 + + @staticmethod + def _any_nontrivial_nus(nus): + if nus is None: + return False + for nu in nus: + if nu is not None: + return True + return False + + def xsec_gradients(self, thetas, nus=None, events="all", test_split=0.2, gradients="all", batch_size=100000): + """ + Returns the gradient of total cross sections with respect to parameters. + + Parameters + ---------- + thetas : list of (ndarray or str), optional + If None, the function returns all benchmark cross sections. Otherwise, it returns the cross sections for a + series of parameter points that are either given by their benchmark name (as a str), their benchmark index + (as an int), or their parameter value (as an ndarray, using morphing). Default value: None. + + nus : None or list of (None or ndarray), optional + If None, the nuisance parameters are set to their nominal values (0), i.e. no systematics are taken into + account. Otherwise, the list has to have the same number of elements as thetas, and each entry can specify + nuisance parameters at nominal value (None) or a value of the nuisance parameters (ndarray). + + test_split : float, optional + Fraction of events reserved for testing. Default value: 0.2. + + events : {"train", "test", "all"}, optional + Which events to use. Default: "all". + + gradients : {"all", "theta", "nu"}, optional + Which gradients to calculate. Default value: "all". + + batch_size : int, optional + Size of the batches of events that are loaded into memory at the same time. Default value: 100000. + + Returns + ------- + xsecs_gradients : ndarray + Calculated cross section gradients in pb with shape (n_gradients,). + """ + + logger.debug("Calculating cross section gradients for thetas = %s and nus = %s", thetas, nus) + + # Inputs + include_nuisance_benchmarks = nus is not None or gradients in ["all", "nu"] + if nus is None: + nus = [None for _ in thetas] + assert len(nus) == len(thetas), "Numbers of thetas and nus don't match!" + if gradients not in ["all", "theta", "nu"]: + raise RuntimeError("Gradients has to be 'all', 'theta', or 'nu', but got {}".format(gradients)) + + # Which events to use + if events == "all": + start_event, end_event = None, None + correction_factor = 1.0 + elif events == "train": + start_event, end_event, correction_factor = self._train_test_split(True, test_split) + elif events == "test": + start_event, end_event, correction_factor = self._train_test_split(False, test_split) + else: + raise ValueError("Events has to be either 'all', 'train', or 'test', but got {}!".format(events)) + + # Theta matrices (translation of benchmarks to theta, at nominal nuisance params) + theta_matrices = np.asarray( + [self._get_theta_benchmark_matrix(theta) for theta in thetas] + ) # shape (n_thetas, n_benchmarks) + theta_gradient_matrices = np.asarray( + [self._get_dtheta_benchmark_matrix(theta) for theta in thetas] + ) # shape (n_thetas, n_gradients, n_benchmarks) + + # Loop over events + xsec_gradients = 0.0 + + for i_batch, (_, benchmark_weights) in enumerate( + madminer_event_loader( + self.madminer_filename, + start=start_event, + end=end_event, + include_nuisance_parameters=include_nuisance_benchmarks, + benchmark_is_nuisance=self.benchmark_is_nuisance, + batch_size=batch_size, + ) + ): + n_batch, _ = benchmark_weights.shape + logger.debug("Batch %s with %s events", i_batch + 1, n_batch) + + if gradients in ["all", "theta"]: + nom_gradients = mdot( + theta_gradient_matrices, benchmark_weights + ) # Shape (n_thetas, n_phys_gradients, n_batch) + nuisance_factors = self._calculate_nuisance_factors(nus, benchmark_weights) # Shape (n_thetas, n_batch) + try: + dweight_dtheta = nuisance_factors[:, np.newaxis, :] * nom_gradients + except TypeError: + dweight_dtheta = nom_gradients + + if gradients in ["all", "nu"]: + weights_nom = mdot(theta_matrices, benchmark_weights) # Shape (n_thetas, n_batch) + nuisance_factor_gradients = np.asarray( + [self.nuisance_morpher.calculate_nuisance_factor_gradients(nu, benchmark_weights) for nu in nus] + ) # Shape (n_thetas, n_nuisance_gradients, n_batch) + dweight_dnu = nuisance_factor_gradients * weights_nom[:, np.newaxis, :] + + if gradients == "all": + dweight_dall = np.concatenate((dweight_dtheta, dweight_dnu), 1) + elif gradients == "theta": + dweight_dall = dweight_dtheta + elif gradients == "nu": + dweight_dall = dweight_dnu + xsec_gradients += np.sum(dweight_dall, axis=2) + + # Correct for not using all events + xsec_gradients *= correction_factor + + return xsec_gradients + + def _weights(self, thetas, nus, benchmark_weights, theta_matrices=None): + """ + Turns benchmark weights into weights for given parameter points (theta, nu). + + Parameters + ---------- + thetas : list of (ndarray or str) + If None, the function returns all benchmark cross sections. Otherwise, it returns the cross sections for a + series of parameter points that are either given by their benchmark name (as a str), their benchmark index + (as an int), or their parameter value (as an ndarray, using morphing). + + nus : None or list of (None or ndarray) + If None, the nuisance parameters are set to their nominal values (0), i.e. no systematics are taken into + account. Otherwise, the list has to have the same number of elements as thetas, and each entry can specify + nuisance parameters at nominal value (None) or a value of the nuisance parameters (ndarray). + + Returns + ------- + weights : ndarray + Calculated weights in pb. + """ + + n_events, _ = benchmark_weights.shape + + # Inputs + include_nuisance_benchmarks = nus is not None + if nus is None: + nus = [None for _ in thetas] + assert len(nus) == len(thetas), "Numbers of thetas and nus don't match!" + + # Theta matrices (translation of benchmarks to theta, at nominal nuisance params) + if theta_matrices is None: + theta_matrices = [self._get_theta_benchmark_matrix(theta) for theta in thetas] + theta_matrices = np.asarray(theta_matrices) # Shape (n_thetas, n_benchmarks) + + # Weights at nominal nuisance params (nu=0) + weights_nom = mdot(theta_matrices, benchmark_weights) # Shape (n_thetas, n_batch) + + # Effect of nuisance parameters + nuisance_factors = self._calculate_nuisance_factors(nus, benchmark_weights) + weights = nuisance_factors * weights_nom + + return weights + + def _weight_gradients( + self, thetas, nus, benchmark_weights, gradients="all", theta_matrices=None, theta_gradient_matrices=None + ): + """ + Turns benchmark weights into weights for given parameter points (theta, nu). + + Parameters + ---------- + thetas : list of (ndarray or str) + If None, the function returns all benchmark cross sections. Otherwise, it returns the cross sections for a + series of parameter points that are either given by their benchmark name (as a str), their benchmark index + (as an int), or their parameter value (as an ndarray, using morphing). + + nus : None or list of (None or ndarray) + If None, the nuisance parameters are set to their nominal values (0), i.e. no systematics are taken into + account. Otherwise, the list has to have the same number of elements as thetas, and each entry can specify + nuisance parameters at nominal value (None) or a value of the nuisance parameters (ndarray). + + gradients : {"all", "theta", "nu"}, optional + Which gradients to calculate. Default value: "all". + + Returns + ------- + gradients : ndarray + Calculated gradients in pb. + """ + + n_events, _ = benchmark_weights.shape + + # Inputs + if gradients == "all" and self.n_nuisance_parameters == 0: + gradients = "theta" + if nus is None: + nus = [None for _ in thetas] + assert len(nus) == len(thetas), "Numbers of thetas and nus don't match!" + + # Theta matrices (translation of benchmarks to theta, at nominal nuisance params) + if theta_matrices is None: + theta_matrices = [self._get_theta_benchmark_matrix(theta) for theta in thetas] + if theta_gradient_matrices is None: + theta_gradient_matrices = [self._get_dtheta_benchmark_matrix(theta) for theta in thetas] + theta_matrices = np.asarray(theta_matrices) # Shape (n_thetas, n_benchmarks) + theta_gradient_matrices = np.asarray(theta_gradient_matrices) # Shape (n_thetas, n_gradients, n_benchmarks) + + # Calculate theta gradient + if gradients in ["all", "theta"]: + nom_gradients = mdot(theta_gradient_matrices, benchmark_weights) # (n_thetas, n_phys_gradients, n_batch) + nuisance_factors = self._calculate_nuisance_factors(nus, benchmark_weights) + try: + dweight_dtheta = nuisance_factors[:, np.newaxis, :] * nom_gradients + except TypeError: + dweight_dtheta = nom_gradients + else: + dweight_dtheta = None + + # Calculate nu gradient + if gradients in ["all", "nu"]: + weights_nom = mdot(theta_matrices, benchmark_weights) # Shape (n_thetas, n_batch) + nuisance_factor_gradients = np.asarray( + [self.nuisance_morpher.calculate_nuisance_factor_gradients(nu, benchmark_weights) for nu in nus] + ) # Shape (n_thetas, n_nuisance_gradients, n_batch) + dweight_dnu = nuisance_factor_gradients * weights_nom[:, np.newaxis, :] + else: + dweight_dnu = None + + if gradients == "theta": + return dweight_dtheta + elif gradients == "nu": + return dweight_dnu + return np.concatenate((dweight_dtheta, dweight_dnu), 1) + + def _train_test_split(self, train, test_split): + """ + Returns the start and end event for train samples (train = True) or test samples (train = False). + + Parameters + ---------- + train : bool + True if training data is generated, False if test data is generated. + + test_split : float + Fraction of events reserved for testing. + + Returns + ------- + start_event : int + Index (in the MadMiner file) of the first event to consider. + + end_event : int + Index (in the MadMiner file) of the last unweighted event to consider. + + correction_factor : float + Factor with which the weights and cross sections will have to be multiplied to make up for the missing + events. + + """ + if train: + start_event = 0 + + if test_split is None or test_split <= 0.0 or test_split >= 1.0: + end_event = None + correction_factor = 1.0 + else: + end_event = int(round((1.0 - test_split) * self.n_samples, 0)) + correction_factor = 1.0 / (1.0 - test_split) + if end_event < 0 or end_event > self.n_samples: + raise ValueError("Irregular train / test split: sample {} / {}", end_event, self.n_samples) + + else: + if test_split is None or test_split <= 0.0 or test_split >= 1.0: + start_event = 0 + correction_factor = 1.0 + else: + start_event = int(round((1.0 - test_split) * self.n_samples, 0)) + 1 + correction_factor = 1.0 / (test_split) + if start_event < 0 or start_event > self.n_samples: + raise ValueError("Irregular train / test split: sample {} / {}", start_event, self.n_samples) + + end_event = None + + return start_event, end_event, correction_factor + + def _get_theta_value(self, theta): + if isinstance(theta, six.string_types): + benchmark = self.benchmarks[theta] + theta_value = np.array([benchmark[key] for key in benchmark]) + elif isinstance(theta, int): + benchmark = self.benchmarks[list(self.benchmarks.keys())[theta]] + theta_value = np.array([benchmark[key] for key in benchmark]) + else: + theta_value = np.asarray(theta) + return theta_value + + def _get_nu_value(self, nu): + if nu is None: + nu_value = np.zeros(self.n_nuisance_parameters) + else: + nu_value = np.asarray(nu) + return nu_value + + def _get_theta_benchmark_matrix(self, theta, zero_pad=True): + """Calculates vector A such that dsigma(theta) = A * dsigma_benchmarks""" + + if zero_pad: + unpadded_theta_matrix = self._get_theta_benchmark_matrix(theta, zero_pad=False) + theta_matrix = np.zeros(self.n_benchmarks) + theta_matrix[: unpadded_theta_matrix.shape[0]] = unpadded_theta_matrix + + elif isinstance(theta, six.string_types): + i_benchmark = list(self.benchmarks).index(theta) + theta_matrix = self._get_theta_benchmark_matrix(i_benchmark) + + elif isinstance(theta, int): + n_benchmarks = len(self.benchmarks) + theta_matrix = np.zeros(n_benchmarks) + theta_matrix[theta] = 1.0 + + else: + theta_matrix = self.morpher.calculate_morphing_weights(theta) + + return theta_matrix + + def _get_dtheta_benchmark_matrix(self, theta, zero_pad=True): + """Calculates matrix A_ij such that d dsigma(theta) / d theta_i = A_ij * dsigma (benchmark j)""" + + if self.morpher is None: + raise RuntimeError("Cannot calculate score without morphing") + + if zero_pad: + unpadded_theta_matrix = self._get_dtheta_benchmark_matrix(theta, zero_pad=False) + dtheta_matrix = np.zeros((unpadded_theta_matrix.shape[0], self.n_benchmarks)) + dtheta_matrix[:, : unpadded_theta_matrix.shape[1]] = unpadded_theta_matrix + + elif isinstance(theta, six.string_types): + benchmark = self.benchmarks[theta] + benchmark = np.array([value for _, value in six.iteritems(benchmark)]) + dtheta_matrix = self._get_dtheta_benchmark_matrix(benchmark) + + elif isinstance(theta, int): + benchmark = self.benchmarks[list(self.benchmarks.keys())[theta]] + benchmark = np.array([value for _, value in six.iteritems(benchmark)]) + dtheta_matrix = self._get_dtheta_benchmark_matrix(benchmark) + + else: + dtheta_matrix = self.morpher.calculate_morphing_weight_gradient( + theta + ) # Shape (n_parameters, n_benchmarks_phys) + + return dtheta_matrix diff --git a/madminer/core.py b/madminer/core.py index caca7e3f9..37cafc9e4 100644 --- a/madminer/core.py +++ b/madminer/core.py @@ -6,11 +6,11 @@ from collections import OrderedDict import tempfile -from madminer.morphing import Morpher +from madminer.utils.morphing import PhysicsMorpher from madminer.utils.interfaces.madminer_hdf5 import save_madminer_settings, load_madminer_settings from madminer.utils.interfaces.mg_cards import export_param_card, export_reweight_card, export_run_card from madminer.utils.interfaces.mg import generate_mg_process, setup_mg_with_scripts, run_mg, create_master_script -from madminer.utils.various import create_missing_folders, format_benchmark, make_file_executable, copy_file +from madminer.utils.various import create_missing_folders, format_benchmark, copy_file logger = logging.getLogger(__name__) @@ -336,7 +336,7 @@ def set_morphing( if isinstance(max_overall_power, int): max_overall_power = (max_overall_power,) - morpher = Morpher(parameters_from_madminer=self.parameters) + morpher = PhysicsMorpher(parameters_from_madminer=self.parameters) morpher.find_components(max_overall_power) if include_existing_benchmarks: @@ -476,7 +476,7 @@ def load(self, filename, disable_morphing=False): self.export_morphing = False if morphing_matrix is not None and morphing_components is not None and not disable_morphing: - self.morpher = Morpher(self.parameters) + self.morpher = PhysicsMorpher(self.parameters) self.morpher.set_components(morphing_components) self.morpher.set_basis(self.benchmarks, morphing_matrix=morphing_matrix) self.export_morphing = True diff --git a/madminer/delphes.py b/madminer/delphes.py index e7d2e258f..9ab1247d1 100644 --- a/madminer/delphes.py +++ b/madminer/delphes.py @@ -19,7 +19,7 @@ logger = logging.getLogger(__name__) -class DelphesProcessor: +class DelphesReader: """ Detector simulation with Delphes and simple calculation of observables. diff --git a/madminer/fisherinformation.py b/madminer/fisherinformation.py index 24dda92fb..44223680f 100755 --- a/madminer/fisherinformation.py +++ b/madminer/fisherinformation.py @@ -2,177 +2,17 @@ import logging import numpy as np -import six import os -from madminer.utils.interfaces.madminer_hdf5 import load_madminer_settings, madminer_event_loader -from madminer.utils.analysis import get_theta_benchmark_matrix, get_dtheta_benchmark_matrix, mdot -from madminer.morphing import Morpher, NuisanceMorpher -from madminer.utils.various import format_benchmark, math_commands, weighted_quantile, sanitize_array -from madminer.ml import MLForge, EnsembleForge +from madminer.analysis import DataAnalyzer +from madminer.utils.various import math_commands, weighted_quantile, sanitize_array, mdot +from madminer.utils.various import separate_information_blocks +from madminer.ml import ScoreEstimator, Ensemble logger = logging.getLogger(__name__) -def project_information(fisher_information, remaining_components, covariance=None): - """ - Calculates projections of a Fisher information matrix, that is, "deletes" the rows and columns corresponding to - some parameters not of interest. - - Parameters - ---------- - fisher_information : ndarray - Original n x n Fisher information. - - remaining_components : list of int - List with m entries, each an int with 0 <= remaining_compoinents[i] < n. Denotes which parameters are kept, and - their new order. All other parameters or projected out. - - covariance : ndarray or None, optional - The covariance matrix of the original Fisher information with shape (n, n, n, n). If None, the error on the - profiled information is not calculated. Default value: None. - - Returns - ------- - projected_fisher_information : ndarray - Projected m x m Fisher information, where the `i`-th row or column corresponds to the - `remaining_components[i]`-th row or column of fisher_information. - - profiled_fisher_information_covariance : ndarray - Covariance matrix of the projected Fisher information matrix with shape (m, m, m, m). Only returned if - covariance is not None. - - """ - n_new = len(remaining_components) - fisher_information_new = np.zeros([n_new, n_new]) - - # Project information - for xnew, xold in enumerate(remaining_components): - for ynew, yold in enumerate(remaining_components): - fisher_information_new[xnew, ynew] = fisher_information[xold, yold] - - # Project covariance matrix - if covariance is not None: - covariance_new = np.zeros([n_new, n_new, n_new, n_new]) - for xnew, xold in enumerate(remaining_components): - for ynew, yold in enumerate(remaining_components): - for znew, zold in enumerate(remaining_components): - for zznew, zzold in enumerate(remaining_components): - covariance_new[xnew, ynew, znew, zznew] = covariance[xold, yold, zold, zzold] - - return fisher_information_new, covariance_new - - return fisher_information_new - - -def profile_information( - fisher_information, - remaining_components, - covariance=None, - error_propagation_n_ensemble=1000, - error_propagation_factor=1.0e-3, -): - """ - Calculates the profiled Fisher information matrix as defined in Appendix A.4 of arXiv:1612.05261. - - Parameters - ---------- - fisher_information : ndarray - Original n x n Fisher information. - - remaining_components : list of int - List with m entries, each an int with 0 <= remaining_compoinents[i] < n. Denotes which parameters are kept, and - their new order. All other parameters or profiled out. - - covariance : ndarray or None, optional - The covariance matrix of the original Fisher information with shape (n, n, n, n). If None, the error on the - profiled information is not calculated. Default value: None. - - error_propagation_n_ensemble : int, optional - If covariance is not None, this sets the number of Fisher information matrices drawn from a normal distribution - for the Monte-Carlo error propagation. Default value: 1000. - - error_propagation_factor : float, optional - If covariance is not None, this factor multiplies the covariance of the distribution of Fisher information - matrices. Smaller factors can avoid problems with ill-behaved Fisher information matrices. Default value: 1.e-3. - - Returns - ------- - profiled_fisher_information : ndarray - Profiled m x m Fisher information, where the `i`-th row or column corresponds to the - `remaining_components[i]`-th row or column of fisher_information. - - profiled_fisher_information_covariance : ndarray - Covariance matrix of the profiled Fishere information matrix with shape (m, m, m, m). - - """ - - logger.debug("Profiling Fisher information") - - # Group components - n_components = len(fisher_information) - n_remaining_components = len(remaining_components) - - remaining_components_checked = [] - profiled_components = [] - - for i in range(n_components): - if i in remaining_components: - remaining_components_checked.append(i) - else: - profiled_components.append(i) - - assert n_remaining_components == len(remaining_components_checked), "Inconsistent input" - - # Error propagation - if covariance is not None: - # Central value - profiled_information = profile_information( - fisher_information, remaining_components=remaining_components, covariance=None - ) - - # Draw toys - information_toys = np.random.multivariate_normal( - mean=fisher_information.reshape((-1,)), - cov=error_propagation_factor * covariance.reshape(n_components ** 2, n_components ** 2), - size=error_propagation_n_ensemble, - ) - information_toys = information_toys.reshape(-1, n_components, n_components) - - # Profile each toy - profiled_information_toys = np.array( - [ - profile_information(info, remaining_components=remaining_components, covariance=None) - for info in information_toys - ] - ) - - # Calculate ensemble covariance - toy_covariance = np.cov(profiled_information_toys.reshape(-1, n_remaining_components ** 2).T) - toy_covariance = toy_covariance.reshape( - (n_remaining_components, n_remaining_components, n_remaining_components, n_remaining_components) - ) - profiled_information_covariance = toy_covariance / error_propagation_factor - - # Cross-check: toy mean - toy_mean = np.mean(profiled_information_toys, axis=0) - logger.debug("Central Fisher info:\n%s\nToy mean Fisher info:\n%s", profiled_information, toy_mean) - - return profiled_information, profiled_information_covariance - - # Separate Fisher information parts - information_phys = fisher_information[remaining_components, :][:, remaining_components] - information_mix = fisher_information[profiled_components, :][:, remaining_components] - information_nuisance = fisher_information[profiled_components, :][:, profiled_components] - - # Calculate profiled information - inverse_information_nuisance = np.linalg.inv(information_nuisance) - profiled_information = information_phys - information_mix.T.dot(inverse_information_nuisance.dot(information_mix)) - - return profiled_information - - -class FisherInformation: +class FisherInformation(DataAnalyzer): """ Functions to calculate expected Fisher information matrices. @@ -208,83 +48,7 @@ class FisherInformation: """ def __init__(self, filename, include_nuisance_parameters=True): - # Save settings - self.madminer_filename = filename - self.include_nuisance_parameters = include_nuisance_parameters - - logger.info("Loading data from %s", filename) - - # Load data - ( - self.parameters, - self.benchmarks, - self.benchmark_is_nuisance, - self.morphing_components, - self.morphing_matrix, - self.observables, - self.n_samples, - _, - self.reference_benchmark, - self.nuisance_parameters, - ) = load_madminer_settings(filename, include_nuisance_benchmarks=include_nuisance_parameters) - self.n_parameters = len(self.parameters) - self.n_benchmarks = len(self.benchmarks) - self.n_benchmarks_phys = np.sum(np.logical_not(self.benchmark_is_nuisance)) - - self.n_nuisance_parameters = 0 - if self.nuisance_parameters is not None and include_nuisance_parameters: - self.n_nuisance_parameters = len(self.nuisance_parameters) - else: - self.nuisance_parameters = None - - logger.info("Found %s parameters", len(self.parameters)) - for key, values in six.iteritems(self.parameters): - logger.debug( - " %s (LHA: %s %s, maximal power in squared ME: %s, range: %s)", - key, - values[0], - values[1], - values[2], - values[3], - ) - - if self.nuisance_parameters is not None and include_nuisance_parameters: - logger.info("Found %s nuisance parameters", self.n_nuisance_parameters) - for key, values in six.iteritems(self.nuisance_parameters): - logger.debug(" %s (%s)", key, values) - elif include_nuisance_parameters: - self.include_nuisance_parameters = False - logger.warning("Did not find nuisance parameters!") - - logger.info("Found %s benchmarks, of which %s physical", self.n_benchmarks, self.n_benchmarks_phys) - for (key, values), is_nuisance in zip(six.iteritems(self.benchmarks), self.benchmark_is_nuisance): - if is_nuisance: - logger.debug(" %s: nuisance parameter", key) - else: - logger.debug(" %s: %s", key, format_benchmark(values)) - - logger.info("Found %s observables: %s", len(self.observables), ", ".join(self.observables)) - logger.info("Found %s events", self.n_samples) - - # Morphing - self.morpher = None - if self.morphing_matrix is not None and self.morphing_components is not None: - self.morpher = Morpher(self.parameters) - self.morpher.set_components(self.morphing_components) - self.morpher.set_basis(self.benchmarks, morphing_matrix=self.morphing_matrix) - - logger.info("Found morphing setup with %s components", len(self.morphing_components)) - - else: - raise RuntimeError("Did not find morphing setup.") - - # Nuisance morphing - self.nuisance_morpher = None - if self.include_nuisance_parameters: - self.nuisance_morpher = NuisanceMorpher( - self.nuisance_parameters, list(self.benchmarks.keys()), self.reference_benchmark - ) - logger.info("Found nuisance morphing setup") + super(FisherInformation, self).__init__(filename, False, include_nuisance_parameters) def calculate_fisher_information_full_truth( self, theta, luminosity=300000.0, cuts=None, efficiency_functions=None, include_nuisance_parameters=True @@ -339,9 +103,7 @@ def calculate_fisher_information_full_truth( fisher_info = np.zeros((n_all_parameters, n_all_parameters)) covariance = np.zeros((n_all_parameters, n_all_parameters, n_all_parameters, n_all_parameters)) - for observations, weights in madminer_event_loader( - self.madminer_filename, include_nuisance_parameters=include_nuisance_parameters - ): + for observations, weights in self.event_loader(): # Cuts cut_filter = [self._pass_cuts(obs_event, cuts) for obs_event in observations] observations = observations[cut_filter] @@ -375,10 +137,9 @@ def calculate_fisher_information_full_detector( luminosity=300000.0, include_xsec_info=True, mode="score", - uncertainty="ensemble", - ensemble_vote_expectation_weight=None, + calculate_covariance=True, batch_size=100000, - test_split=0.5, + test_split=0.2, ): """ Calculates the full Fisher information in realistic detector-level observations, estimated with neural networks. @@ -393,7 +154,7 @@ def calculate_fisher_information_full_detector( model_file : str Filename of a trained local score regression model that was trained on samples from `theta` (see - `madminer.ml.MLForge`). + `madminer.ml.Estimator`). unweighted_x_sample_file : str or None Filename of an unweighted x sample that is sampled according to theta and obeys the cuts @@ -412,24 +173,15 @@ def calculate_fisher_information_full_detector( are the sample mean and covariance calculated. If mode is "score", the sample mean is calculated for the score for each event. Default value: "score". - uncertainty : {"ensemble", "expectation", "sum"}, optional - How the covariance matrix of the Fisher information estimate is calculated. With "ensemble", the ensemble - covariance is used. With "expectation", the expectation of the score is used as a measure of the uncertainty - of the score estimator, and this uncertainty is propagated through to the covariance matrix. With "sum", - both terms are summed. Default value: "ensemble". - - ensemble_vote_expectation_weight : float or list of float or None, optional - For ensemble models, the factor that determines how much more weight is given to those estimators with small - expectation value. If a list is given, results are returned for each element in the list. If None, or if - `EnsembleForge.calculate_expectation()` has not been called, all estimators are treated equal. Default - value: None. + calculate_covariance : bool, optional + If True, the covariance between the different estimators is calculated. Default value: True. batch_size : int, optional Batch size. Default value: 100000. test_split : float or None, optional If unweighted_x_sample_file is None, this determines the fraction of weighted events used for evaluation. - If None, all events are used (this will probably include events used during training!). Default value: 0.5. + If None, all events are used (this will probably include events used during training!). Default value: 0.2. Returns ------- @@ -451,13 +203,13 @@ def calculate_fisher_information_full_detector( raise ValueError("Unknown mode {}, has to be 'score' or 'information'!".format(mode)) # Load SALLY model - if os.path.isdir(model_file): + if os.path.isdir(model_file) and os.path.exists(model_file + "/ensemble.json"): model_is_ensemble = True - model = EnsembleForge() + model = Ensemble() model.load(model_file) else: model_is_ensemble = False - model = MLForge() + model = ScoreEstimator() model.load(model_file) # Nuisance parameters? @@ -519,7 +271,7 @@ def calculate_fisher_information_full_detector( total_sum_weights_theta = total_xsec # Theta morphing matrix - theta_matrix = get_theta_benchmark_matrix("morphing", theta, self.benchmarks, self.morpher) + theta_matrix = self._get_theta_benchmark_matrix(theta) # Prepare output fisher_info_kin = None @@ -530,11 +282,8 @@ def calculate_fisher_information_full_detector( n_batches_verbose = max(int(round(n_batches / 10, 0)), 1) for i_batch, (observations, weights_benchmarks) in enumerate( - madminer_event_loader( - self.madminer_filename, - batch_size=batch_size, - start=start_event, - include_nuisance_parameters=include_nuisance_parameters, + self.event_loader( + batch_size=batch_size, start=start_event, include_nuisance_parameters=include_nuisance_parameters ) ): if (i_batch + 1) % n_batches_verbose == 0: @@ -550,9 +299,8 @@ def calculate_fisher_information_full_detector( x=observations, obs_weights=weights_theta, n_events=luminosity * total_xsec * np.sum(weights_theta) / total_sum_weights_theta, - vote_expectation_weight=ensemble_vote_expectation_weight, + calculate_covariance=calculate_covariance, mode=mode, - uncertainty=uncertainty, ) else: this_fisher_info = model.calculate_fisher_information( @@ -584,30 +332,20 @@ def calculate_fisher_information_full_detector( else: if model_is_ensemble: fisher_info_kin, covariance = model.calculate_fisher_information( - unweighted_x_sample_file, + x=unweighted_x_sample_file, n_events=luminosity * total_xsec, - vote_expectation_weight=ensemble_vote_expectation_weight, mode=mode, - uncertainty=uncertainty, + calculate_covariance=calculate_covariance, ) else: fisher_info_kin = model.calculate_fisher_information( - unweighted_x_sample_file, n_events=luminosity * total_xsec + x=unweighted_x_sample_file, n_events=luminosity * total_xsec ) covariance = None # Returns if model_is_ensemble: - if isinstance(ensemble_vote_expectation_weight, list) and len(ensemble_vote_expectation_weight) > 1: - fisher_info_results = [ - fisher_info_rate + this_fisher_info_kin for this_fisher_info_kin in fisher_info_kin - ] - covariance_results = [rate_covariance + this_covariance for this_covariance in covariance] - - return fisher_info_results, covariance_results - - else: - return fisher_info_rate + fisher_info_kin, rate_covariance + covariance + return fisher_info_rate + fisher_info_kin, rate_covariance + covariance return fisher_info_rate + fisher_info_kin, rate_covariance @@ -754,7 +492,7 @@ def calculate_fisher_information_hist1d( weights_benchmarks = np.zeros((n_bins_total, self.n_benchmarks)) weights_squared_benchmarks = np.zeros((n_bins_total, self.n_benchmarks)) - for observations, weights in madminer_event_loader(self.madminer_filename): + for observations, weights in self.event_loader(): # Cuts cut_filter = [self._pass_cuts(obs_event, cuts) for obs_event in observations] observations = observations[cut_filter] @@ -901,7 +639,7 @@ def calculate_fisher_information_hist2d( weights_benchmarks = np.zeros((n_bins1_total, n_bins2_total, self.n_benchmarks)) weights_squared_benchmarks = np.zeros((n_bins1_total, n_bins2_total, self.n_benchmarks)) - for observations, weights in madminer_event_loader(self.madminer_filename): + for observations, weights in self.event_loader(): # Cuts cut_filter = [self._pass_cuts(obs_event, cuts) for obs_event in observations] observations = observations[cut_filter] @@ -963,7 +701,7 @@ def histogram_of_fisher_information( cuts=None, efficiency_functions=None, batch_size=100000, - test_split=0.5, + test_split=0.2, ): """ Calculates the full and rate-only Fisher information in slices of one observable. For the full @@ -987,7 +725,8 @@ def histogram_of_fisher_information( model_file : str or None, optional If None, the truth-level Fisher information is calculated. If str, filename of a trained local score - regression model that was trained on samples from `theta` (see `madminer.ml.MLForge`). Default value: None. + regression model that was trained on samples from `theta` (see `madminer.ml.Estimator`). Default value: + None. luminosity : float, optional Luminosity in pb^-1. Default value: 300000. @@ -1006,7 +745,7 @@ def histogram_of_fisher_information( test_split : float or None, optional If model_file is not None: If unweighted_x_sample_file is None, this determines the fraction of weighted events used for evaluation. - If None, all events are used (this will probably include events used during training!). Default value: 0.5. + If None, all events are used (this will probably include events used during training!). Default value: 0.2. Returns @@ -1033,7 +772,7 @@ def histogram_of_fisher_information( efficiency_functions = [] # Theta morphing matrix - theta_matrix = get_theta_benchmark_matrix("morphing", theta, self.benchmarks, self.morpher) + theta_matrix = self._get_theta_benchmark_matrix(theta) # Number of bins n_bins_total = nbins + 2 @@ -1045,7 +784,7 @@ def histogram_of_fisher_information( # Main loop: truth-level case if model_file is None: - for observations, weights in madminer_event_loader(self.madminer_filename): + for observations, weights in self.event_loader(): # Cuts cut_filter = [self._pass_cuts(obs_event, cuts) for obs_event in observations] observations = observations[cut_filter] @@ -1081,13 +820,13 @@ def histogram_of_fisher_information( # ML case else: # Load SALLY model - if os.path.isdir(model_file): + if os.path.isdir(model_file) and os.path.exists(model_file + "/ensemble.json"): model_is_ensemble = True - model = EnsembleForge() + model = Ensemble() model.load(model_file) else: model_is_ensemble = False - model = MLForge() + model = ScoreEstimator() model.load(model_file) # Nuisance parameters? @@ -1128,11 +867,8 @@ def histogram_of_fisher_information( # ML main loop for i_batch, (observations, weights_benchmarks) in enumerate( - madminer_event_loader( - self.madminer_filename, - batch_size=batch_size, - start=start_event, - include_nuisance_parameters=include_nuisance_parameters, + self.event_loader( + batch_size=batch_size, start=start_event, include_nuisance_parameters=include_nuisance_parameters ) ): if (i_batch + 1) % n_batches_verbose == 0: @@ -1160,7 +896,7 @@ def histogram_of_fisher_information( obs_weights=weights_theta, n_events=luminosity * np.sum(weights_theta), mode="score", - uncertainty="none", + calculate_covariance=False, sum_events=False, ) else: @@ -1224,69 +960,6 @@ def calculate_fisher_information_nuisance_constraints(self): diagonal = np.array([0.0 for _ in range(self.n_parameters)] + [1.0 for _ in range(self.n_nuisance_parameters)]) return np.diag(diagonal) - def extract_raw_data(self, theta=None): - - """ - Returns all events together with the benchmark weights (if theta is None) or weights for a given theta. - - Parameters - ---------- - theta : None or ndarray, optional - If None, the function returns the benchmark weights. Otherwise it uses morphing to calculate the weights for - this value of theta. Default value: None. - - Returns - ------- - x : ndarray - Observables with shape `(n_unweighted_samples, n_observables)`. - - weights : ndarray - If theta is None, benchmark weights with shape `(n_unweighted_samples, n_benchmarks_phys)` in pb. Otherwise, - weights for the given parameter theta with shape `(n_unweighted_samples,)` in pb. - - """ - - x, weights_benchmarks = next(madminer_event_loader(self.madminer_filename, batch_size=None)) - - if theta is not None: - theta_matrix = get_theta_benchmark_matrix("morphing", theta, self.benchmarks, self.morpher) - - weights_theta = mdot(theta_matrix, weights_benchmarks) - - return x, weights_theta - - return x, weights_benchmarks - - def extract_observables_and_weights(self, thetas): - """ - Extracts observables and weights for given parameter points. - - Parameters - ---------- - thetas : ndarray - Parameter points, with shape `(n_thetas, n_parameters)`. - - Returns - ------- - x : ndarray - Observations `x` with shape `(n_events, n_observables)`. - - weights : ndarray - Weights `dsigma(x|theta)` in pb with shape `(n_thetas, n_events)`. - - """ - - x, weights_benchmarks = next(madminer_event_loader(self.madminer_filename, batch_size=None)) - - weights_thetas = [] - for theta in thetas: - theta_matrix = get_theta_benchmark_matrix("morphing", theta, self.benchmarks, self.morpher) - weights_thetas.append(mdot(theta_matrix, weights_benchmarks)) - - weights_thetas = np.array(weights_thetas) - - return x, weights_thetas - def _calculate_fisher_information( self, theta, @@ -1343,13 +1016,11 @@ def _calculate_fisher_information( """ + include_nuisance_parameters = include_nuisance_parameters and self.include_nuisance_parameters + # Get morphing matrices - theta_matrix = get_theta_benchmark_matrix( - "morphing", theta, self.benchmarks, self.morpher - ) # (n_benchmarks_phys,) - dtheta_matrix = get_dtheta_benchmark_matrix( - "morphing", theta, self.benchmarks, self.morpher - ) # (n_parameters, n_benchmarks_phys) + theta_matrix = self._get_theta_benchmark_matrix(theta, zero_pad=False) # (n_benchmarks_phys,) + dtheta_matrix = self._get_dtheta_benchmark_matrix(theta, zero_pad=False) # (n_parameters, n_benchmarks_phys) # Get differential xsec per event, and the derivative wrt to theta sigma = mdot(theta_matrix, weights_benchmarks) # Shape (n_events,) @@ -1361,7 +1032,7 @@ def _calculate_fisher_information( fisher_info_phys = luminosity * np.einsum("n,in,jn->nij", inv_sigma, dsigma, dsigma) # Nuisance parameter Fisher info - if include_nuisance_parameters and self.include_nuisance_parameters: + if include_nuisance_parameters: nuisance_a = self.nuisance_morpher.calculate_a(weights_benchmarks) # Shape (n_nuisance_params, n_events) # grad_i dsigma(x), where i is a nuisance parameter, is given by # sigma[np.newaxis, :] * a @@ -1383,10 +1054,12 @@ def _calculate_fisher_information( # Error propagation if calculate_uncertainty: - weights_benchmarks_phys = weights_benchmarks[:, np.logical_not(self.benchmark_is_nuisance)] + if weights_benchmarks.shape[1] > self.n_benchmarks_phys: + weights_benchmarks_phys = weights_benchmarks[:, np.logical_not(self.benchmark_is_nuisance)] + else: + weights_benchmarks_phys = weights_benchmarks n_events = weights_benchmarks_phys.shape[0] - n_benchmarks_phys = weights_benchmarks_phys.shape[1] # Input uncertainties if weights_benchmark_uncertainties is None: @@ -1394,10 +1067,10 @@ def _calculate_fisher_information( # Build covariance matrix of inputs # We assume full correlation between weights_benchmarks[i, b1] and weights_benchmarks[i, b2] - covariance_inputs = np.zeros((n_events, n_benchmarks_phys, n_benchmarks_phys)) + covariance_inputs = np.zeros((n_events, self.n_benchmarks_phys, self.n_benchmarks_phys)) for i in range(n_events): - for b1 in range(n_benchmarks_phys): - for b2 in range(n_benchmarks_phys): + for b1 in range(self.n_benchmarks_phys): + for b2 in range(self.n_benchmarks_phys): if b1 == b2: # Diagonal covariance_inputs[i, b1, b2] = weights_benchmark_uncertainties[i, b1] ** 2 @@ -1611,8 +1284,8 @@ def _calculate_xsec( xsecs_benchmarks = None xsecs_uncertainty_benchmarks = None - for observations, weights in madminer_event_loader( - self.madminer_filename, start=start_event, include_nuisance_parameters=include_nuisance_parameters + for observations, weights in self.event_loader( + start=start_event, include_nuisance_parameters=include_nuisance_parameters ): # Cuts cut_filter = [self._pass_cuts(obs_event, cuts) for obs_event in observations] @@ -1645,7 +1318,7 @@ def _calculate_xsec( return xsecs_benchmarks # Translate to xsec for theta - theta_matrix = get_theta_benchmark_matrix("morphing", theta, self.benchmarks, self.morpher) + theta_matrix = self._get_theta_benchmark_matrix(theta) xsec = mdot(theta_matrix, xsecs_benchmarks) xsec_error = mdot(theta_matrix, xsecs_uncertainty_benchmarks) @@ -1669,7 +1342,7 @@ def _calculate_dynamic_binning( quantile_values = np.linspace(0.0, 1.0, n_bins + 1) # Get data - x_pilot, weights_pilot = next(madminer_event_loader(self.madminer_filename, batch_size=n_events)) + x_pilot, weights_pilot = next(self.event_loader(batch_size=n_events)) # Cuts cut_filter = [self._pass_cuts(x, cuts) for x in x_pilot] @@ -1684,7 +1357,7 @@ def _calculate_dynamic_binning( histo_observables_pilot = np.asarray([self._eval_observable(x, observable) for x in x_pilot]) # Weights at theta - theta_matrix = get_theta_benchmark_matrix("morphing", theta, self.benchmarks, self.morpher) + theta_matrix = self._get_theta_benchmark_matrix(theta) weight_theta_pilot = mdot(theta_matrix, weights_pilot) # Bin boundaries @@ -1692,3 +1365,147 @@ def _calculate_dynamic_binning( bin_boundaries = bin_boundaries[1:-1] return bin_boundaries + + +def project_information(fisher_information, remaining_components, covariance=None): + """ + Calculates projections of a Fisher information matrix, that is, "deletes" the rows and columns corresponding to + some parameters not of interest. + + Parameters + ---------- + fisher_information : ndarray + Original n x n Fisher information. + + remaining_components : list of int + List with m entries, each an int with 0 <= remaining_compoinents[i] < n. Denotes which parameters are kept, and + their new order. All other parameters or projected out. + + covariance : ndarray or None, optional + The covariance matrix of the original Fisher information with shape (n, n, n, n). If None, the error on the + profiled information is not calculated. Default value: None. + + Returns + ------- + projected_fisher_information : ndarray + Projected m x m Fisher information, where the `i`-th row or column corresponds to the + `remaining_components[i]`-th row or column of fisher_information. + + profiled_fisher_information_covariance : ndarray + Covariance matrix of the projected Fisher information matrix with shape (m, m, m, m). Only returned if + covariance is not None. + + """ + n_new = len(remaining_components) + fisher_information_new = np.zeros([n_new, n_new]) + + # Project information + for xnew, xold in enumerate(remaining_components): + for ynew, yold in enumerate(remaining_components): + fisher_information_new[xnew, ynew] = fisher_information[xold, yold] + + # Project covariance matrix + if covariance is not None: + covariance_new = np.zeros([n_new, n_new, n_new, n_new]) + for xnew, xold in enumerate(remaining_components): + for ynew, yold in enumerate(remaining_components): + for znew, zold in enumerate(remaining_components): + for zznew, zzold in enumerate(remaining_components): + covariance_new[xnew, ynew, znew, zznew] = covariance[xold, yold, zold, zzold] + + return fisher_information_new, covariance_new + + return fisher_information_new + + +def profile_information( + fisher_information, + remaining_components, + covariance=None, + error_propagation_n_ensemble=1000, + error_propagation_factor=1.0e-3, +): + """ + Calculates the profiled Fisher information matrix as defined in Appendix A.4 of arXiv:1612.05261. + + Parameters + ---------- + fisher_information : ndarray + Original n x n Fisher information. + + remaining_components : list of int + List with m entries, each an int with 0 <= remaining_compoinents[i] < n. Denotes which parameters are kept, and + their new order. All other parameters or profiled out. + + covariance : ndarray or None, optional + The covariance matrix of the original Fisher information with shape (n, n, n, n). If None, the error on the + profiled information is not calculated. Default value: None. + + error_propagation_n_ensemble : int, optional + If covariance is not None, this sets the number of Fisher information matrices drawn from a normal distribution + for the Monte-Carlo error propagation. Default value: 1000. + + error_propagation_factor : float, optional + If covariance is not None, this factor multiplies the covariance of the distribution of Fisher information + matrices. Smaller factors can avoid problems with ill-behaved Fisher information matrices. Default value: 1.e-3. + + Returns + ------- + profiled_fisher_information : ndarray + Profiled m x m Fisher information, where the `i`-th row or column corresponds to the + `remaining_components[i]`-th row or column of fisher_information. + + profiled_fisher_information_covariance : ndarray + Covariance matrix of the profiled Fishere information matrix with shape (m, m, m, m). + + """ + + logger.debug("Profiling Fisher information") + n_components = len(fisher_information) + n_remaining_components = len(remaining_components) + + _, information_phys, information_mix, information_nuisance = separate_information_blocks( + fisher_information, remaining_components + ) + + # Error propagation + if covariance is not None: + # Central value + profiled_information = profile_information( + fisher_information, remaining_components=remaining_components, covariance=None + ) + + # Draw toys + information_toys = np.random.multivariate_normal( + mean=fisher_information.reshape((-1,)), + cov=error_propagation_factor * covariance.reshape(n_components ** 2, n_components ** 2), + size=error_propagation_n_ensemble, + ) + information_toys = information_toys.reshape(-1, n_components, n_components) + + # Profile each toy + profiled_information_toys = np.array( + [ + profile_information(info, remaining_components=remaining_components, covariance=None) + for info in information_toys + ] + ) + + # Calculate ensemble covariance + toy_covariance = np.cov(profiled_information_toys.reshape(-1, n_remaining_components ** 2).T) + toy_covariance = toy_covariance.reshape( + (n_remaining_components, n_remaining_components, n_remaining_components, n_remaining_components) + ) + profiled_information_covariance = toy_covariance / error_propagation_factor + + # Cross-check: toy mean + toy_mean = np.mean(profiled_information_toys, axis=0) + logger.debug("Central Fisher info:\n%s\nToy mean Fisher info:\n%s", profiled_information, toy_mean) + + return profiled_information, profiled_information_covariance + + # Calculate profiled information + inverse_information_nuisance = np.linalg.inv(information_nuisance) + profiled_information = information_phys - information_mix.T.dot(inverse_information_nuisance.dot(information_mix)) + + return profiled_information diff --git a/madminer/lhe.py b/madminer/lhe.py index 0b9c66df2..7c594d0f7 100644 --- a/madminer/lhe.py +++ b/madminer/lhe.py @@ -19,7 +19,7 @@ logger = logging.getLogger(__name__) -class LHEProcessor: +class LHEReader: """ Detector simulation with smearing functions and simple calculation of observables. @@ -40,6 +40,7 @@ class LHEProcessor: `LHEProcessor.add_observable_from_function()`. A simple set of default observables is provided in `LHEProcessor.add_default_observables()` * Optionally, cuts can be set with `LHEProcessor.add_cut()` + * Optionally, efficiencies can be set with `LHEProcessor.add_efficiency()` * Calculating the observables from the Delphes ROOT files with `LHEProcessor.analyse_delphes_samples()` * Saving the results with `LHEProcessor.save()` @@ -68,6 +69,10 @@ def __init__(self, filename): self.cuts = [] self.cuts_default_pass = [] + # Initialize efficiencies + self.efficiencies = [] + self.efficiencies_default_pass = [] + # Smearing function parameters self.energy_resolution = {} self.pt_resolution = {} @@ -448,6 +453,38 @@ def add_cut(self, definition, pass_if_not_parsed=False): self.cuts.append(definition) self.cuts_default_pass.append(pass_if_not_parsed) + def add_efficiency(self, definition, value_if_not_parsed=1.0): + + """ + Adds an efficiency as a string that can be parsed by Python's `eval()` function and returns a bool. + + Parameters + ---------- + definition : str + An expression that can be parsed by Python's `eval()` function and returns a floating number which reweights + the event weights. In the definition, all visible particles can be used: `e`, `mu`, `j`, `a`, and `l` provide + lists of electrons, muons, jets, photons, and leptons (electrons and muons combined), in each case sorted + by descending transverse momentum. `met` provides a missing ET object. `visible` and `all` provide access to + the sum of all visible particles and the sum of all visible particles plus MET, respectively. All these + objects are instances of `MadMinerParticle`, which inherits from scikit-hep's + [LorentzVector](http://scikit-hep.org/api/math.html#vector-classes). See the link for a + documentation of their properties. In addition, `MadMinerParticle` have properties `charge` and `pdg_id`, + which return the charge in units of elementary charges (i.e. an electron has `e[0].charge = -1.`), and the + PDG particle ID. + + value_if_not_parsed : float, optional + Value if te efficiency function cannot be parsed. Default value: 1. + + Returns + ------- + None + + """ + logger.debug("Adding efficiency %s", definition) + + self.efficiencies.append(definition) + self.efficiencies_default_pass.append(value_if_not_parsed) + def reset_observables(self): """ Resets all observables. """ @@ -465,10 +502,18 @@ def reset_cuts(self): self.cuts = [] self.cuts_default_pass = [] + def reset_efficiencies(self): + """ Resets all efficiencies. """ + + logger.debug("Resetting efficiencies") + + self.efficiencies = [] + self.efficiencies_default_pass = [] + def analyse_samples(self, reference_benchmark=None, parse_events_as_xml=True): """ - Main function that parses the LHE samples, applies detector effects, checks cuts, and extracts - the observables and weights. + Main function that parses the LHE samples, applies detector effects, checks cuts, + evaulate efficiencies, and extracts the observables and weights. Parameters ---------- @@ -570,6 +615,8 @@ def _parse_sample( observables_defaults=self.observables_defaults, cuts=self.cuts, cuts_default_pass=self.cuts_default_pass, + efficiencies=self.efficiencies, + efficiencies_default_pass=self.efficiencies_default_pass, energy_resolutions=self.energy_resolution, pt_resolutions=self.pt_resolution, eta_resolutions=self.eta_resolution, @@ -587,6 +634,7 @@ def _parse_sample( n_events = None for key, obs in six.iteritems(this_observations): this_n_events = len(obs) + logger.debug("Found {} events in Obs {}".format(this_n_events, key)) if n_events is None: n_events = this_n_events logger.debug("Found %s events", n_events) diff --git a/madminer/limits.py b/madminer/limits.py new file mode 100644 index 000000000..3e21805e5 --- /dev/null +++ b/madminer/limits.py @@ -0,0 +1,378 @@ +from __future__ import absolute_import, division, print_function, unicode_literals + +import logging +import numpy as np +import os +from scipy.stats import chi2, poisson + +from madminer.analysis import DataAnalyzer +from madminer.utils.various import mdot +from madminer.ml import ParameterizedRatioEstimator, Ensemble +from madminer.utils.histo import Histo +from madminer.sampling import SampleAugmenter +from madminer import sampling +from madminer.ml import ScoreEstimator + +logger = logging.getLogger(__name__) + + +class AsymptoticLimits(DataAnalyzer): + """ + Functions to calculate observed and expected constraints, using asymptotic properties of the likelihood ratio as + test statistics. + + Parameters + ---------- + filename : str + Path to MadMiner file (for instance the output of `madminer.delphes.DelphesProcessor.save()`). + + include_nuisance_parameters : bool, optional + If True, nuisance parameters are taken into account. Default value: False. + """ + + def __init__(self, filename=None, include_nuisance_parameters=False): + super(AsymptoticLimits, self).__init__(filename, False, include_nuisance_parameters) + + def observed_limits( + self, + x_observed, + theta_ranges, + mode="ml", + model_file=None, + hist_vars=None, + hist_bins=20, + include_xsec=True, + resolutions=25, + luminosity=300000.0, + ): + theta_grid, p_values, i_ml = self._analyse( + len(x_observed), + x_observed, + theta_ranges, + resolutions, + mode, + model_file, + hist_vars, + hist_bins, + include_xsec, + None, + luminosity, + ) + return theta_grid, p_values, i_ml + + def expected_limits( + self, + theta_true, + theta_ranges, + mode="ml", + model_file=None, + hist_vars=None, + hist_bins=20, + include_xsec=True, + resolutions=25, + luminosity=300000.0, + ): + x_asimov, x_weights = self._asimov_data(theta_true) + n_observed = luminosity * self._calculate_xsecs([theta_true])[0] + theta_grid, p_values, i_ml = self._analyse( + n_observed, + x_asimov, + theta_ranges, + resolutions, + mode, + model_file, + hist_vars, + hist_bins, + include_xsec, + x_weights, + luminosity, + ) + return theta_grid, p_values, i_ml + + def asymptotic_p_value(self, log_likelihood_ratio): + q = -2.0 * log_likelihood_ratio + p_value = chi2.sf(x=q, df=self.n_parameters) + return p_value + + def _analyse( + self, + n_events, + x, + theta_ranges, + theta_resolutions, + mode="ml", + model_file=None, + hist_vars=None, + hist_bins=20, + include_xsec=True, + obs_weights=None, + luminosity=300000.0, + ): + logger.debug("Calculating p-values for %s expected events", n_events) + + # Observation weights + if obs_weights is None: + obs_weights = np.ones(len(x)) + obs_weights /= np.sum(obs_weights) + obs_weights = obs_weights.astype(np.float64) + + # Theta grid + theta_grid = self._make_theta_grid(theta_ranges, theta_resolutions) + + # Kinematic part + if mode == "rate": + log_r_kin = 0.0 + elif mode == "ml": + assert model_file is not None + logger.info("Loading kinematic likelihood ratio estimator") + model = self._load_ratio_model(model_file) + + logger.info("Calculating kinematic log likelihood ratio with estimator") + log_r_kin = self._calculate_log_likelihood_ratio_kinematics(x, theta_grid, model) + log_r_kin = log_r_kin.astype(np.float64) + log_r_kin = self._clean_nans(log_r_kin) + logger.debug("Raw mean -2 log r: %s", np.mean(-2.0 * log_r_kin, axis=1)) + log_r_kin = n_events * np.sum(log_r_kin * obs_weights[np.newaxis, :], axis=1) + logger.debug("Rescaled -2 log r: %s", -2.0 * log_r_kin) + + elif mode == "histo": + if hist_vars is not None: + logger.info("Setting up standard summary statistics") + summary_function = self._make_summary_statistic_function("observables", observables=hist_vars) + elif model_file is not None: + logger.info("Loading score estimator and setting it up as summary statistics") + model = self._load_score_model(model_file) + summary_function = self._make_summary_statistic_function("sally", model=model) + else: + raise RuntimeError("For 'histo' mode, either provide histo_vars or model_file!") + summary_stats = summary_function(x) + + logger.info("Creating histogram with %s bins for the summary statistics", hist_bins) + histo = self._make_histo(summary_function, hist_bins, theta_grid, theta_resolutions) + + logger.info("Calculating kinematic log likelihood with histograms") + log_r_kin = self._calculate_log_likelihood_histo(summary_stats, theta_grid, histo) + log_r_kin = log_r_kin.astype(np.float64) + log_r_kin = self._clean_nans(log_r_kin) + log_r_kin = n_events * np.sum(log_r_kin * obs_weights[np.newaxis, :], axis=1) + + else: + raise ValueError("Unknown mode {}, has to be 'ml' or 'histo' or 'xsec'".format(mode)) + + # xsec part + if include_xsec: + logger.info("Calculating rate log likelihood") + log_p_xsec = self._calculate_log_likelihood_xsec(n_events, theta_grid, luminosity) + logger.debug("Rate -2 log p: %s", -2.0 * log_p_xsec) + else: + log_p_xsec = 0.0 + + # Combine and get p-values + logger.info("Calculating p-values") + log_r = log_r_kin + log_p_xsec + logger.debug("Combined -2 log r: %s", -2.0 * log_r) + log_r, i_ml = self._subtract_ml(log_r) + logger.debug("Min-subtracted -2 log r: %s", -2.0 * log_r) + p_values = self.asymptotic_p_value(log_r) + + return theta_grid, p_values, i_ml + + def _make_summary_statistic_function(self, mode, model=None, observables=None): + if mode == "observables": + assert observables is not None + x_indices = self._find_x_indices(observables) + + def summary_function(x): + return x[:, x_indices] + + elif mode == "sally": + assert isinstance(model, ScoreEstimator) + + def summary_function(x): + return model.evaluate_score(x) + + else: + raise RuntimeError("Unknown mode {}, has to be 'observables' or 'sally'".format(mode)) + + return summary_function + + @staticmethod + def _load_ratio_model(filename): + if os.path.isdir(filename): + model = Ensemble() + model.load(filename) + else: + model = ParameterizedRatioEstimator() + model.load(filename) + return model + + @staticmethod + def _load_score_model(filename): + if os.path.isdir(filename): + model = Ensemble() + model.load(filename) + else: + model = ScoreEstimator() + model.load(filename) + return model + + def _calculate_xsecs(self, thetas, test_split=0.2): + # Test split + start_event, end_event = self._train_test_split(False, test_split) + + # Total xsecs for benchmarks + xsecs_benchmarks = 0.0 + for observations, weights in self.event_loader(start=start_event, end=end_event): + xsecs_benchmarks += np.sum(weights, axis=0) + + # xsecs at thetas + xsecs = [] + for theta in thetas: + theta_matrix = self._get_theta_benchmark_matrix(theta) + xsecs.append(mdot(theta_matrix, xsecs_benchmarks)) + return np.asarray(xsecs) + + def _asimov_data(self, theta, test_split=0.2): + start_event, end_event = self._train_test_split(False, test_split) + x, weights_benchmarks = next(self.event_loader(start=start_event, end=end_event, batch_size=None)) + + theta_matrix = self._get_theta_benchmark_matrix(theta) + weights_theta = mdot(theta_matrix, weights_benchmarks) + weights_theta /= np.sum(weights_theta) + + return x, weights_theta + + @staticmethod + def _make_theta_grid(theta_ranges, resolutions): + if isinstance(resolutions, int): + resolutions = [resolutions for _ in range(theta_ranges)] + theta_each = [] + for resolution, (theta_min, theta_max) in zip(resolutions, theta_ranges): + theta_each.append(np.linspace(theta_min, theta_max, resolution)) + theta_grid_each = np.meshgrid(*theta_each) + theta_grid_each = [theta.flatten() for theta in theta_grid_each] + theta_grid = np.vstack(theta_grid_each).T + return theta_grid + + def _make_histo(self, summary_function, x_bins, theta_grid, theta_bins, n_samples_per_theta=1000): + logger.info("Building histogram with %s bins per parameter and %s bins per observable") + histo = Histo(theta_bins, x_bins) + theta, x = self._make_histo_data(theta_grid, n_samples_per_theta * len(theta_grid)) + summary_stats = summary_function(x) + histo.fit(theta, summary_stats, fill_empty_bins=True) + return histo + + def _make_histo_data(self, thetas, n_samples, test_split=0.2): + sampler = SampleAugmenter(self.madminer_filename, include_nuisance_parameters=self.include_nuisance_parameters) + x, theta, _ = sampler.sample_train_plain( + theta=sampling.morphing_points(thetas), + n_samples=n_samples, + test_split=test_split, + filename=None, + folder=None, + ) + return theta, x + + def _find_x_indices(self, observables): + x_names = list(self.observables.keys()) + x_indices = [] + for obs in observables: + try: + x_indices.append(x_names.index(obs)) + except ValueError: + raise RuntimeError("Unknown observable {}, has to be one of {}".format(obs, x_names)) + logger.debug("Using x indices %s", x_indices) + return x_indices + + @staticmethod + def _calculate_log_likelihood_histo(x, theta_grid, histo): + log_p = [] + for theta in theta_grid: + log_p.append(histo.log_likelihood(theta, x)) + log_p = np.asarray(log_p) + return log_p + + def _calculate_log_likelihood_xsec(self, n_observed, theta_grid, luminosity=300000.0): + n_observed_rounded = int(np.round(n_observed, 0)) + n_predicted = self._calculate_xsecs(theta_grid) * luminosity + logger.debug("Observed events: %s", n_observed) + logger.debug("Expected events: %s", n_predicted) + log_p = poisson.logpmf(k=n_observed_rounded, mu=n_predicted) + return log_p + + def _calculate_log_likelihood_ratio_kinematics(self, x_observed, theta_grid, model, theta1=None): + if isinstance(model, ParameterizedRatioEstimator): + log_r, _ = model.evaluate_log_likelihood_ratio( + x=x_observed, theta=theta_grid, test_all_combinations=True, evaluate_score=False + ) + elif isinstance(model, Ensemble) and model.estimator_type == "parameterized_ratio": + log_r, _ = model.evaluate_log_likelihood_ratio( + x=x_observed, + theta=theta_grid, + test_all_combinations=True, + evaluate_score=False, + calculate_covariance=False, + ) + else: + raise NotImplementedError( + "Likelihood ratio estimation is currently only implemented for " + "ParameterizedRatioEstimator instancees" + ) + return log_r + + @staticmethod + def _subtract_ml(log_r): + i_ml = np.argmax(log_r) + log_r_subtracted = log_r[:] - log_r[i_ml] + return log_r_subtracted, i_ml + + @staticmethod + def _clean_nans(array): + not_finite = np.any(~np.isfinite(array), axis=0) + if np.sum(not_finite) > 0: + logger.warning("Removing %s inf / nan results from calculation") + array[:, not_finite] = 0.0 + return array + + def _train_test_split(self, train, test_split): + """ + Returns the start and end event for train samples (train = True) or test samples (train = False). + + Parameters + ---------- + train : bool + True if training data is generated, False if test data is generated. + + test_split : float + Fraction of events reserved for testing. + + Returns + ------- + start_event : int + Index of the first unweighted event to consider. + + end_event : int + Index of the last unweighted event to consider. + + """ + if train: + start_event = 0 + + if test_split is None or test_split <= 0.0 or test_split >= 1.0: + end_event = None + else: + end_event = int(round((1.0 - test_split) * self.n_samples, 0)) + if end_event < 0 or end_event > self.n_samples: + raise ValueError("Irregular train / test split: sample {} / {}", end_event, self.n_samples) + + else: + if test_split is None or test_split <= 0.0 or test_split >= 1.0: + start_event = 0 + else: + start_event = int(round((1.0 - test_split) * self.n_samples, 0)) + 1 + if start_event < 0 or start_event > self.n_samples: + raise ValueError("Irregular train / test split: sample {} / {}", start_event, self.n_samples) + + end_event = None + + return start_event, end_event diff --git a/madminer/ml.py b/madminer/ml.py index 2cc868716..c8ba0a037 100644 --- a/madminer/ml.py +++ b/madminer/ml.py @@ -5,72 +5,251 @@ import os import json import numpy as np +from collections import OrderedDict import torch -from torch import optim from madminer.utils.ml.models.maf import ConditionalMaskedAutoregressiveFlow from madminer.utils.ml.models.maf_mog import ConditionalMixtureMaskedAutoregressiveFlow -from madminer.utils.ml.models.ratio import ParameterizedRatioEstimator, DoublyParameterizedRatioEstimator -from madminer.utils.ml.models.score import LocalScoreEstimator +from madminer.utils.ml.models.ratio import DenseSingleParameterizedRatioModel, DenseDoublyParameterizedRatioModel +from madminer.utils.ml.models.score import DenseLocalScoreModel from madminer.utils.ml.eval import evaluate_flow_model, evaluate_ratio_model, evaluate_local_score_model -from madminer.utils.ml.utils import check_required_data +from madminer.utils.ml.utils import get_optimizer, get_loss from madminer.utils.various import create_missing_folders, load_and_check, shuffle, restrict_samplesize -from madminer.utils.ml.methods import get_method_type, get_trainer, get_loss, package_training_data +from madminer.utils.various import separate_information_blocks +from madminer.utils.ml.trainer import SingleParameterizedRatioTrainer, DoubleParameterizedRatioTrainer +from madminer.utils.ml.trainer import LocalScoreTrainer, FlowTrainer logger = logging.getLogger(__name__) -class MLForge: +class Estimator(object): """ - Estimating likelihood ratios and scores with machine learning. + Abstract class for any ML estimator. Subclassed by ParameterizedRatioEstimator, DoubleParameterizedRatioEstimator, + ScoreEstimator, and LikelihoodEstimator. Each instance of this class represents one neural estimator. The most important functions are: - * `MLForge.train()` to train an estimator. The keyword `method` determines the inference technique + * `Estimator.train()` to train an estimator. The keyword `method` determines the inference technique and whether a class instance represents a single-parameterized likelihood ratio estimator, a doubly-parameterized likelihood ratio estimator, or a local score estimator. - * `MLForge.evaluate()` to evaluate the estimator. - * `MLForge.save()` to save the trained model to files. - * `MLForge.load()` to load the trained model from files. + * `Estimator.evaluate()` to evaluate the estimator. + * `Estimator.save()` to save the trained model to files. + * `Estimator.load()` to load the trained model from files. Please see the tutorial for a detailed walk-through. """ - def __init__(self): - self.method_type = None + def __init__(self, features=None, n_hidden=(100, 100), activation="tanh"): + self.features = features + self.n_hidden = n_hidden + self.activation = activation + self.model = None - self.method = None - self.nde_type = None self.n_observables = None self.n_parameters = None - self.n_hidden = None - self.activation = None - self.maf_n_mades = None - self.maf_batch_norm = None - self.maf_batch_norm_alpha = None - self.maf_mog_n_components = None - self.features = None self.x_scaling_means = None self.x_scaling_stds = None + def train(self, *args, **kwargs): + raise NotImplementedError + + def evaluate_log_likelihood(self, *args, **kwargs): + """ + Log likelihood estimation. Signature depends on the type of estimator. The first returned value is the log + likelihood with shape `(n_thetas, n_x)`. + """ + raise NotImplementedError + + def evaluate_log_likelihood_ratio(self, *args, **kwargs): + """ + Log likelihood ratio estimation. Signature depends on the type of estimator. The first returned value is the log + likelihood ratio with shape `(n_thetas, n_x)` or `(n_x)`. + """ + raise NotImplementedError + + def evaluate_score(self, *args, **kwargs): + """ + Score estimation. Signature depends on the type of estimator. The only returned value is the score with shape + `(n_x)`. + """ + raise NotImplementedError + + def evaluate(self, *args, **kwargs): + raise NotImplementedError + + def calculate_fisher_information(self, *args, **kwargs): + raise NotImplementedError + + def save(self, filename, save_model=False): + + """ + Saves the trained model to four files: a JSON file with the settings, a pickled pyTorch state dict + file, and numpy files for the mean and variance of the inputs (used for input scaling). + + Parameters + ---------- + filename : str + Path to the files. '_settings.json' and '_state_dict.pl' will be added. + + save_model : bool, optional + If True, the whole model is saved in addition to the state dict. This is not necessary for loading it + again with Estimator.load(), but can be useful for debugging, for instance to plot the computational graph. + + Returns + ------- + None + + """ + + if self.model is None: + raise ValueError("No model -- train or load model before saving!") + + # Check paths + create_missing_folders([os.path.dirname(filename)]) + + # Save settings + logger.debug("Saving settings to %s_settings.json", filename) + + settings = self._wrap_settings() + + with open(filename + "_settings.json", "w") as f: + json.dump(settings, f) + + # Save scaling + if self.x_scaling_stds is not None and self.x_scaling_means is not None: + logger.debug("Saving input scaling information to %s_x_means.npy and %s_x_stds.npy", filename, filename) + np.save(filename + "_x_means.npy", self.x_scaling_means) + np.save(filename + "_x_stds.npy", self.x_scaling_stds) + + # Save state dict + logger.debug("Saving state dictionary to %s_state_dict.pt", filename) + torch.save(self.model.state_dict(), filename + "_state_dict.pt") + + # Save model + if save_model: + logger.debug("Saving model to %s_model.pt", filename) + torch.save(self.model, filename + "_model.pt") + + def load(self, filename): + + """ + Loads a trained model from files. + + Parameters + ---------- + filename : str + Path to the files. '_settings.json' and '_state_dict.pl' will be added. + + Returns + ------- + None + + """ + + # Load settings and create model + logger.debug("Loading settings from %s_settings.json", filename) + with open(filename + "_settings.json", "r") as f: + settings = json.load(f) + self._unwrap_settings(settings) + self._create_model() + + # Load scaling + try: + self.x_scaling_means = np.load(filename + "_x_means.npy") + self.x_scaling_stds = np.load(filename + "_x_stds.npy") + logger.debug( + " Found input scaling information: means %s, stds %s", self.x_scaling_means, self.x_scaling_stds + ) + except FileNotFoundError: + logger.warning("Scaling information not found in %s", filename) + self.x_scaling_means = None + self.x_scaling_stds = None + + # Load state dict + logger.debug("Loading state dictionary from %s_state_dict.pt", filename) + self.model.load_state_dict(torch.load(filename + "_state_dict.pt", map_location="cpu")) + + def _initialize_input_transform(self, x, transform=True): + if transform: + self.x_scaling_means = np.mean(x, axis=0) + self.x_scaling_stds = np.maximum(np.std(x, axis=0), 1.0e-6) + else: + n_parameters = x.shape[0] + + self.x_scaling_means = np.zeros(n_parameters) + self.x_scaling_stds = np.ones(n_parameters) + + def _transform_inputs(self, x): + if self.x_scaling_means is not None and self.x_scaling_stds is not None: + x_scaled = x - self.x_scaling_means + x_scaled /= self.x_scaling_stds + else: + x_scaled = x + return x_scaled + + def _wrap_settings(self): + settings = { + "n_observables": self.n_observables, + "n_parameters": self.n_parameters, + "features": self.features, + "n_hidden": list(self.n_hidden), + "activation": self.activation, + } + return settings + + def _unwrap_settings(self, settings): + try: + _ = str(settings["estimator_type"]) + except KeyError: + raise RuntimeError( + "Can't find estimator type information in file. Maybe this file was created with" + " an incompatible MadMiner version < v0.3.0?" + ) + + self.n_observables = int(settings["n_observables"]) + self.n_parameters = int(settings["n_parameters"]) + self.n_hidden = tuple([int(item) for item in settings["n_hidden"]]) + self.activation = str(settings["activation"]) + self.features = settings["features"] + if self.features == "None": + self.features = None + if self.features is not None: + self.features = list([int(item) for item in self.features]) + + def _create_model(self): + raise NotImplementedError + + +class ParameterizedRatioEstimator(Estimator): + """ + A neural estimator of the likelihood ratio as a function of the observation x as well as + the numerator hypothesis theta. The reference (denominator) hypothesis is kept fixed at some + reference value and NOT modeled by the network. + + Parameters + ---------- + features : list of int or None, optional + Indices of observables (features) that are used as input to the neural networks. If None, all observables + are used. Default value: None. + + n_hidden : tuple of int, optional + Units in each hidden layer in the neural networks. If method is 'nde' or 'scandal', this refers to the + setup of each individual MADE layer. Default value: (100, 100). + + activation : {'tanh', 'sigmoid', 'relu'}, optional + Activation function. Default value: 'tanh'. + + + """ + def train( self, method, - x_filename, - y_filename=None, - theta0_filename=None, - theta1_filename=None, - r_xz_filename=None, - t_xz0_filename=None, - t_xz1_filename=None, - features=None, - nde_type="mafmog", - n_hidden=(100, 100), - activation="tanh", - maf_n_mades=3, - maf_batch_norm=False, - maf_batch_norm_alpha=0.1, - maf_mog_n_components=10, + x, + y, + theta, + r_xz=None, + t_xz=None, alpha=1.0, optimizer="amsgrad", n_epochs=50, @@ -82,105 +261,38 @@ def train( early_stopping=True, scale_inputs=True, shuffle_labels=False, - grad_x_regularization=None, limit_samplesize=None, verbose="some", ): """ - Trains a neural network to estimate either the likelihood, the likelihood ratio, or the - score. - - The keyword method determines the structure of the estimator that an instance of this class represents: - - * For 'alice', 'alices', 'carl', 'nde', 'rascal', 'rolr', and 'scandal', the neural network models - the likelihood ratio as a function of the observables `x` and the numerator hypothesis `theta0`, while - the denominator hypothesis is kept at a fixed reference value ("single-parameterized likelihood ratio - estimator"). In addition to the likelihood ratio, the estimator allows to estimate the score at `theta0`. - * For 'alice2', 'alices2', 'carl2', 'rascal2', and 'rolr2', the neural network models - the likelihood ratio as a function of the observables `x`, the numerator hypothesis `theta0`, and the - denominator hypothesis `theta1` ("doubly parameterized likelihood ratio estimator"). The score at `theta0` - and `theta1` can also be evaluated. - * For 'sally' and 'sallino', the neural networks models the score evaluated at some reference hypothesis - ("local score regression"). The likelihood ratio cannot be estimated directly from the neural network, but - can be estimated in a second step through density estimation in the estimated score space. + Trains the network. Parameters ---------- method : str - The inference method used. Allows values are 'alice', 'alices', 'carl', 'nde', 'rascal', 'rolr', and - 'scandal' for a single-parameterized likelihood ratio estimator; 'alice2', 'alices2', 'carl2', 'rascal2', - and 'rolr2' for a doubly-parameterized likelihood ratio estimator; and 'sally' and 'sallino' for local - score regression. - - x_filename : str + The inference method used for training. Allowed values are 'alice', 'alices', 'carl', 'cascal', 'rascal', + and 'rolr'. + + x : ndarray or str Path to an unweighted sample of observations, as saved by the `madminer.sampling.SampleAugmenter` functions. Required for all inference methods. - - y_filename : str or None, optional - Path to an unweighted sample of class labels, as saved by the `madminer.sampling.SampleAugmenter` functions. - Required for the 'alice', 'alice2', 'alices', 'alices2', 'carl', 'carl2', 'rascal', 'rascal2', 'rolr', - and 'rolr2' methods. Default value: None. - - theta0_filename : str or None, optional - Path to an unweighted sample of numerator parameters, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required for the 'alice', 'alice2', 'alices', 'alices2', 'carl', 'carl2', 'nde', 'rascal', - 'rascal2', 'rolr', 'rolr2', and 'scandal' methods. Default value: None. - - theta1_filename : str or None, optional - Path to an unweighted sample of denominator parameters, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required for the 'alice2', 'alices2', 'carl2', 'rascal2', and 'rolr2' methods. Default value: - None. - - r_xz_filename : str or None, optional - Path to an unweighted sample of joint likelihood ratios, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required for the 'alice', 'alice2', 'alices', 'alices2', 'rascal', 'rascal2', 'rolr', and 'rolr2' - methods. Default value: None. - - t_xz0_filename : str or None, optional - Path to an unweighted sample of joint scores at theta0, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required for the 'alices', 'alices2', 'rascal', 'rascal2', 'sallino', 'sally', and 'scandal' - methods. Default value: None. - - t_xz1_filename : str or None, optional - Path to an unweighted sample of joint scores at theta1, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required for the 'rascal2' and 'alices2' methods. Default value: None. - - features : list of int or None, optional - Indices of observables (features) that are used as input to the neural networks. If None, all observables - are used. Default value: None. - - nde_type : {'maf', 'mafmog'}, optional - If the method is 'nde' or 'scandal', nde_type determines the architecture used in the neural density - estimator. Currently supported are 'maf' for a Masked Autoregressive Flow with a Gaussian base density, or - 'mafmog' for a Masked Autoregressive Flow with a mixture of Gaussian base densities. Default value: - 'mafmog'. - - n_hidden : tuple of int, optional - Units in each hidden layer in the neural networks. If method is 'nde' or 'scandal', this refers to the - setup of each individual MADE layer. Default value: (100, 100). - - activation : {'tanh', 'sigmoid', 'relu'}, optional - Activation function. Default value: 'tanh'. - - maf_n_mades : int, optional - If method is 'nde' or 'scandal', this sets the number of MADE layers. Default value: 3. - - maf_batch_norm : bool, optional - If method is 'nde' or 'scandal', switches batch normalization layers after each MADE layer on or off. - Default: False. - - maf_batch_norm_alpha : float, optional - If method is 'nde' or 'scandal' and maf_batch_norm is True, this sets the alpha parameter in the calculation - of the running average of the mean and variance. Default value: 0.1. - - maf_mog_n_components : int, optional - If method is 'nde' or 'scandal' and nde_type is 'mafmog', this sets the number of Gaussian base components. - Default value: 10. + + y : ndarray or str + Class labels (0 = numeerator, 1 = denominator), or filename of a pickled numpy array. + + theta : ndarray or str + Numerator parameter point, or filename of a pickled numpy array. + + r_xz : ndarray or str or None, optional + Joint likelihood ratio, or filename of a pickled numpy array. Default value: None. + + t_xz : ndarray or str or None, optional + Joint scores at theta, or filename of a pickled numpy array. Default value: None. alpha : float, optional - Hyperparameter weighting the score error in the loss function of the 'alices', 'alices2', 'rascal', - 'rascal2', and 'scandal' methods. Default value: 1. + Hyperparameter weighting the score error in the loss function of the 'alices', 'rascal', and 'cascal' + methods. Default value: 1. optimizer : {"adam", "amsgrad", "sgd"}, optional Optimization algorithm. Default value: "amsgrad". @@ -217,9 +329,6 @@ def train( normal order. This serves as a closure test, in particular as cross-check against overfitting: an estimator trained with shuffle_labels=True should predict to likelihood ratios around 1 and scores around 0. - grad_x_regularization : None - Currently not supported. - limit_samplesize : int or None, optional If not None, only this number of samples (events) is used to train the estimator. Default value: None. @@ -234,35 +343,7 @@ def train( logger.info("Starting training") logger.info(" Method: %s", method) - logger.info(" Training data: x at %s", x_filename) - if theta0_filename is not None: - logger.info(" theta0 at %s", theta0_filename) - if theta1_filename is not None: - logger.info(" theta1 at %s", theta1_filename) - if y_filename is not None: - logger.info(" y at %s", y_filename) - if r_xz_filename is not None: - logger.info(" r_xz at %s", r_xz_filename) - if t_xz0_filename is not None: - logger.info(" t_xz (theta0) at %s", t_xz0_filename) - if t_xz1_filename is not None: - logger.info(" t_xz (theta1) at %s", t_xz1_filename) - if features is None: - logger.info(" Features: all") - else: - logger.info(" Features: %s", features) - logger.info(" Method: %s", method) - if method in ["nde", "scandal"]: - logger.info(" Neural density est.: %s", nde_type) - if method not in ["nde", "scandal"]: - logger.info(" Hidden layers: %s", n_hidden) - if method in ["nde", "scandal"]: - logger.info(" MAF, number MADEs: %s", maf_n_mades) - logger.info(" MAF, batch norm: %s", maf_batch_norm) - logger.info(" MAF, BN alpha: %s", maf_batch_norm_alpha) - logger.info(" MAF MoG, components: %s", maf_mog_n_components) - logger.info(" Activation function: %s", activation) - if method in ["cascal", "cascal2", "rascal", "rascal2", "scandal", "alices"]: + if method in ["cascal", "rascal", "alices"]: logger.info(" alpha: %s", alpha) logger.info(" Batch size: %s", batch_size) logger.info(" Optimizer: %s", optimizer) @@ -279,41 +360,26 @@ def train( else: logger.info(" Samples: %s", limit_samplesize) - # Check - if grad_x_regularization is not None: - logger.warning("grad_x_regularization is not supported in this version of MadMiner") - # Load training data logger.info("Loading training data") - theta0 = load_and_check(theta0_filename) - theta1 = load_and_check(theta1_filename) - x = load_and_check(x_filename) - y = load_and_check(y_filename) - r_xz = load_and_check(r_xz_filename) - t_xz0 = load_and_check(t_xz0_filename) - t_xz1 = load_and_check(t_xz1_filename) - if y is not None: - y = y.reshape((-1, 1)) - - # Check necessary information is there - if not check_required_data(method, r_xz, t_xz0, t_xz1, theta0, theta1, x, y): - raise ValueError("Not all required data for method {} provided!".format(method)) + theta = load_and_check(theta) + x = load_and_check(x) + y = load_and_check(y) + r_xz = load_and_check(r_xz) + t_xz = load_and_check(t_xz) + + self._check_required_data(method, r_xz, t_xz) # Infer dimensions of problem n_samples = x.shape[0] n_observables = x.shape[1] - if theta0 is not None: - n_parameters = theta0.shape[1] - else: - n_parameters = t_xz0.shape[1] + n_parameters = theta.shape[1] logger.info("Found %s samples with %s parameters and %s observables", n_samples, n_parameters, n_observables) # Limit sample size if limit_samplesize is not None and limit_samplesize < n_samples: logger.info("Only using %s of %s training samples", limit_samplesize, n_samples) - x, theta0, theta1, y, r_xz, t_xz0, t_xz1 = restrict_samplesize( - limit_samplesize, x, theta0, theta1, y, r_xz, t_xz0, t_xz1 - ) + x, theta, y, r_xz, t_xz = restrict_samplesize(limit_samplesize, x, theta, y, r_xz, t_xz) # Scale features if scale_inputs: @@ -323,67 +389,49 @@ def train( else: self._initialize_input_transform(x, False) - logger.debug("Observable ranges:") - for i in range(n_observables): - logger.debug( - " x_%s: mean %s, std %s, range %s ... %s", - i + 1, - np.mean(x[:, i]), - np.std(x[:, i]), - np.min(x[:, i]), - np.max(x[:, i]), - ) - # Shuffle labels if shuffle_labels: logger.info("Shuffling labels") - y, r_xz, t_xz0, t_xz1 = shuffle(y, r_xz, t_xz0, t_xz1) + y, r_xz, t_xz = shuffle(y, r_xz, t_xz) # Features - self.features = features - if features is not None: - x = x[:, features] + if self.features is not None: + x = x[:, self.features] logger.info("Only using %s of %s observables", x.shape[1], n_observables) n_observables = x.shape[1] + # Check consistency of input with model + if self.n_observables is None: + self.n_observables = n_observables + if self.n_parameters is None: + self.n_parameters = n_parameters + + if n_parameters != self.n_parameters: + raise RuntimeError( + "Number of parameters does not match model: {} vs {}".format(n_parameters, self.n_parameters) + ) + if n_observables != self.n_observables: + raise RuntimeError( + "Number of observables does not match model: {} vs {}".format(n_observables, self.n_observables) + ) + # Data - data = package_training_data(method, x, theta0, theta1, y, r_xz, t_xz0, t_xz1) - - # Create model and save settings - logger.info("Creating model for method %s", method) - self._create_model( - method, - n_observables, - n_parameters, - n_hidden, - activation, - nde_type, - maf_n_mades, - maf_batch_norm, - maf_batch_norm_alpha, - maf_mog_n_components, - ) + data = self._package_training_data(method, x, theta, y, r_xz, t_xz) + + # Create model + if self.model is None: + logger.info("Creating model") + self._create_model() # Losses loss_functions, loss_labels, loss_weights = get_loss(method, alpha) # Optimizer - opt_kwargs = None - if optimizer == "adam": - opt = optim.Adam - elif optimizer == "amsgrad": - opt = optim.Adam - opt_kwargs = {"amsgrad": True} - elif optimizer == "sgd": - opt = optim.SGD - if nesterov_momentum is not None: - opt_kwargs = {"momentum": nesterov_momentum} - else: - raise ValueError("Unknown optimizer {}".format(optimizer)) + opt, opt_kwargs = get_optimizer(optimizer, nesterov_momentum) # Train model logger.info("Training model") - trainer = get_trainer(method)(self.model) + trainer = SingleParameterizedRatioTrainer(self.model) result = trainer.train( data=data, loss_functions=loss_functions, @@ -401,146 +449,47 @@ def train( ) return result - def evaluate(self, x, theta0_filename=None, theta1_filename=None, test_all_combinations=True, evaluate_score=False): - - """ - Evaluates a trained estimator of the log likelihood ratio, the log likelihood, or the score, depending on the - method. - - Parameters - ---------- - x : str or ndarray - Sample of observations, or path to numpy file with observations, as saved by the - `madminer.sampling.SampleAugmenter` functions. - - theta0_filename : str or None, optional - Path to an unweighted sample of numerator parameters, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required if the estimator was trained with the 'alice', 'alice2', 'alices', 'alices2', 'carl', - 'carl2', 'nde', 'rascal', 'rascal2', 'rolr', 'rolr2', or 'scandal' method. Default value: None. - - theta1_filename : str or None, optional - Path to an unweighted sample of denominator parameters, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required if the estimator was trained with the 'alice2', 'alices2', 'carl2', 'rascal2', or - 'rolr2' method. Default value: None. - - test_all_combinations : bool, optional - If method is not 'sally' and not 'sallino': If False, the number of samples in the observable and theta - files has to match, and the likelihood ratio is evaluated only for the combinations - `r(x_i | theta0_i, theta1_i)`. If True, `r(x_i | theta0_j, theta1_j)` for all pairwise combinations `i, j` - are evaluated. Default value: True. - - evaluate_score : bool, optional - If method is not 'sally' and not 'sallino', this sets whether in addition to the likelihood ratio the score - is evaluated. Default value: False. - - return_grad_x : bool, optional - If True, `grad_x log r(x)` or `grad_x t(x)` (for 'sally' or 'sallino' estimators) are returned in addition - to the other outputs. Default value: False. - - Returns - ------- - sally_estimated_score : ndarray - Only returned if the network was trained with `method='sally'` or `method='sallino'`. In this case, an - array of the estimator for `t(x_i | theta_ref)` is returned for all events `i`. - - log_likelihood_ratio : ndarray - Only returned if the network was trained with neither `method='sally'` nor `method='sallino'`. The estimated - log likelihood ratio. If test_all_combinations is True, the result has shape `(n_thetas, n_x)`. Otherwise, - it has shape `(n_samples,)`. - - score_theta0 : ndarray or None - Only returned if the network was trained with neither `method='sally'` nor `method='sallino'`. None if - evaluate_score is False. Otherwise the derived estimated score at `theta0`. If test_all_combinations is - True, the result has shape `(n_thetas, n_x, n_parameters)`. Otherwise, it has shape - `(n_samples, n_parameters)`. - - score_theta1 : ndarray or None - Only returned if the network was trained with neither `method='sally'` nor `method='sallino'`. None if - evaluate_score is False, or the network was trained with any method other than 'alice2', 'alices2', 'carl2', - 'rascal2', or 'rolr2'. Otherwise the derived estimated score at `theta1`. If test_all_combinations is - True, the result has shape `(n_thetas, n_x, n_parameters)`. Otherwise, it has shape - `(n_samples, n_parameters)`. - - grad_x : ndarray - Only returned if return_grad_x is True. - - """ - if self.method_type in ["parameterized", "doubly_parameterized"]: - return self.evaluate_log_likelihood_ratio( - x, theta0_filename, theta1_filename, test_all_combinations, evaluate_score - ) - elif self.method_type == "nde": - return self.evaluate_log_likelihood(x, theta0_filename, test_all_combinations, evaluate_score) - elif self.method_type == "local_score": - return self.evaluate_score(x) - else: - raise RuntimeError("Unknown method type %s", self.method_type) - - def evaluate_log_likelihood_ratio( - self, x, theta0_filename=None, theta1_filename=None, test_all_combinations=True, evaluate_score=False - ): - + def evaluate_log_likelihood_ratio(self, x, theta, test_all_combinations=True, evaluate_score=False): """ - Evaluates a trained estimator of the log likelihood ratio, the log likelihood, or the score, depending on the - method. + Evaluates the log likelihood ratio for given observations x betwen the given parameter point theta and the + reference hypothesis. Parameters ---------- x : str or ndarray - Sample of observations, or path to numpy file with observations, as saved by the - `madminer.sampling.SampleAugmenter` functions. - - theta0_filename : str or None, optional - Path to an unweighted sample of numerator parameters, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required if the estimator was trained with the 'alice', 'alice2', 'alices', 'alices2', 'carl', - 'carl2', 'nde', 'rascal', 'rascal2', 'rolr', 'rolr2', or 'scandal' method. Default value: None. + Observations or filename of a pickled numpy array. - theta1_filename : str or None, optional - Path to an unweighted sample of denominator parameters, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required if the estimator was trained with the 'alice2', 'alices2', 'carl2', 'rascal2', or - 'rolr2' method. Default value: None. + theta : ndarray or str + Parameter points or filename of a pickled numpy array. test_all_combinations : bool, optional - If method is not 'sally' and not 'sallino': If False, the number of samples in the observable and theta + If False, the number of samples in the observable and theta files has to match, and the likelihood ratio is evaluated only for the combinations `r(x_i | theta0_i, theta1_i)`. If True, `r(x_i | theta0_j, theta1_j)` for all pairwise combinations `i, j` are evaluated. Default value: True. evaluate_score : bool, optional - If method is not 'sally' and not 'sallino', this sets whether in addition to the likelihood ratio the score - is evaluated. Default value: False. + Sets whether in addition to the likelihood ratio the score is evaluated. Default value: False. Returns ------- log_likelihood_ratio : ndarray - Only returned if the network was trained with neither `method='sally'` nor `method='sallino'`. The estimated - log likelihood ratio. If test_all_combinations is True, the result has shape `(n_thetas, n_x)`. Otherwise, - it has shape `(n_samples,)`. - - score_theta0 : ndarray or None - Only returned if the network was trained with neither `method='sally'` nor `method='sallino'`. None if - evaluate_score is False. Otherwise the derived estimated score at `theta0`. If test_all_combinations is - True, the result has shape `(n_thetas, n_x, n_parameters)`. Otherwise, it has shape - `(n_samples, n_parameters)`. + The estimated log likelihood ratio. If test_all_combinations is True, the result has shape + `(n_thetas, n_x)`. Otherwise, it has shape `(n_samples,)`. - score_theta1 : ndarray or None - Only returned if the network was trained with neither `method='sally'` nor `method='sallino'`. None if - evaluate_score is False, or the network was trained with any method other than 'alice2', 'alices2', 'carl2', - 'rascal2', or 'rolr2'. Otherwise the derived estimated score at `theta1`. If test_all_combinations is - True, the result has shape `(n_thetas, n_x, n_parameters)`. Otherwise, it has shape + score : ndarray or None + None if evaluate_score is False. Otherwise the derived estimated score at `theta0`. If test_all_combinations + is True, the result has shape `(n_thetas, n_x, n_parameters)`. Otherwise, it has shape `(n_samples, n_parameters)`. """ - if self.model is None: raise ValueError("No model -- train or load model before evaluating it!") # Load training data logger.debug("Loading evaluation data") - theta0s = load_and_check(theta0_filename) - theta1s = load_and_check(theta1_filename) - if isinstance(x, six.string_types): - x = load_and_check(x) + x = load_and_check(x) + theta = load_and_check(theta) # Scale observables x = self._transform_inputs(x) @@ -549,214 +498,866 @@ def evaluate_log_likelihood_ratio( if self.features is not None: x = x[:, self.features] - # Balance thetas - if theta1s is None and theta0s is not None: - theta1s = [None for _ in theta0s] - elif theta1s is not None and theta0s is not None: - if len(theta1s) > len(theta0s): - theta0s = [theta0s[i % len(theta0s)] for i in range(len(theta1s))] - elif len(theta1s) < len(theta0s): - theta1s = [theta1s[i % len(theta1s)] for i in range(len(theta0s))] - - # Evaluation for all other methods all_log_r_hat = [] - all_t_hat0 = [] - all_t_hat1 = [] + all_t_hat = [] if test_all_combinations: logger.debug("Starting ratio evaluation for all combinations") - for i, (theta0, theta1) in enumerate(zip(theta0s, theta1s)): - logger.debug( - "Starting ratio evaluation for thetas %s / %s: %s vs %s", i + 1, len(theta0s), theta0, theta1 - ) - _, log_r_hat, t_hat0, t_hat1 = evaluate_ratio_model( + for i, this_theta in enumerate(theta): + logger.debug("Starting ratio evaluation for thetas %s / %s: %s", i + 1, len(theta), this_theta) + _, log_r_hat, t_hat, _ = evaluate_ratio_model( model=self.model, - method_type=self.method_type, - theta0s=[theta0], - theta1s=[theta1] if theta1 is not None else None, + method_type="parameterized_ratio", + theta0s=[this_theta], + theta1s=None, xs=x, evaluate_score=evaluate_score, ) all_log_r_hat.append(log_r_hat) - all_t_hat0.append(t_hat0) - all_t_hat1.append(t_hat1) + all_t_hat.append(t_hat) all_log_r_hat = np.array(all_log_r_hat) - all_t_hat0 = np.array(all_t_hat0) - all_t_hat1 = np.array(all_t_hat1) + all_t_hat = np.array(all_t_hat) else: logger.debug("Starting ratio evaluation") - _, all_log_r_hat, all_t_hat0, all_t_hat1 = evaluate_ratio_model( + _, all_log_r_hat, all_t_hat, _ = evaluate_ratio_model( model=self.model, - method_type=self.method_type, - theta0s=theta0s, - theta1s=None if None in theta1s else theta1s, + method_type="parameterized_ratio", + theta0s=theta, + theta1s=None, xs=x, evaluate_score=evaluate_score, ) logger.debug("Evaluation done") - return all_log_r_hat, all_t_hat0, all_t_hat1 + return all_log_r_hat, all_t_hat - def evaluate_score(self, x, return_grad_x=False): + def evaluate_log_likelihood(self, *args, **kwargs): + raise TheresAGoodReasonThisDoesntWork( + "This estimator can only estimate likelihood ratios, not the likelihood " "itself!" + ) - """ - Evaluates a trained estimator of the the score. + def evaluate_score(self, *args, **kwargs): + raise NotImplementedError("Please use evaluate_log_likelihood_ratio(evaluate_score=True).") - Parameters - ---------- - x : str or ndarray - Sample of observations, or path to numpy file with observations, as saved by the - `madminer.sampling.SampleAugmenter` functions. + def calculate_fisher_information(self, *args, **kwargs): + raise NotImplementedError( + "Please use evaluate_log_likelihood_ratio(evaluate_score=True) and calculate the " + "Fisher information manually." + ) - return_grad_x : bool, optional - If True, `grad_x log r(x)` or `grad_x t(x)` (for 'sally' or 'sallino' estimators) are returned in addition - to the other outputs. Default value: False. + def evaluate(self, *args, **kwargs): + return self.evaluate_log_likelihood_ratio(*args, **kwargs) - Returns - ------- - sally_estimated_score : ndarray - Only returned if the network was trained with `method='sally'` or `method='sallino'`. In this case, an - array of the estimator for `t(x_i | theta_ref)` is returned for all events `i`. + def _create_model(self): + self.model = DenseSingleParameterizedRatioModel( + n_observables=self.n_observables, + n_parameters=self.n_parameters, + n_hidden=self.n_hidden, + activation=self.activation, + ) - grad_x : ndarray - Only returned if return_grad_x is True. + @staticmethod + def _check_required_data(method, r_xz, t_xz): + if method in ["cascal", "alices", "rascal"] and t_xz is None: + raise RuntimeError("Method {} requires joint score information".format(method)) + if method in ["rolr", "alices", "rascal"] and r_xz is None: + raise RuntimeError("Method {} requires joint likelihood ratio information".format(method)) + + @staticmethod + def _package_training_data(method, x, theta, y, r_xz, t_xz): + data = OrderedDict() + data["x"] = x + data["theta"] = theta + data["y"] = y + if method in ["rolr", "alice", "alices", "rascal"]: + data["r_xz"] = r_xz + if method in ["cascal", "alices", "rascal"]: + data["t_xz"] = t_xz + return data + + def _wrap_settings(self): + settings = super(ParameterizedRatioEstimator, self)._wrap_settings() + settings["estimator_type"] = "parameterized_ratio" + return settings + + def _unwrap_settings(self, settings): + super(ParameterizedRatioEstimator, self)._unwrap_settings(settings) + + estimator_type = str(settings["estimator_type"]) + if estimator_type != "parameterized_ratio": + raise RuntimeError("Saved model is an incompatible estimator type {}.".format(estimator_type)) + + +class DoubleParameterizedRatioEstimator(Estimator): + """ + A neural estimator of the likelihood ratio as a function of the observation x, the numerator hypothesis theta0, and + the denominator hypothesis theta1. - """ + Parameters + ---------- + features : list of int or None, optional + Indices of observables (features) that are used as input to the neural networks. If None, all observables + are used. Default value: None. - if self.model is None: - raise ValueError("No model -- train or load model before evaluating it!") + n_hidden : tuple of int, optional + Units in each hidden layer in the neural networks. If method is 'nde' or 'scandal', this refers to the + setup of each individual MADE layer. Default value: (100, 100). - # Load training data - logger.debug("Loading evaluation data") - if isinstance(x, six.string_types): - x = load_and_check(x) + activation : {'tanh', 'sigmoid', 'relu'}, optional + Activation function. Default value: 'tanh'. - # Scale observables - x = self._transform_inputs(x) - # Restrict featuers + """ + + def train( + self, + method, + x, + y, + theta0, + theta1, + r_xz=None, + t_xz0=None, + t_xz1=None, + alpha=1.0, + optimizer="amsgrad", + n_epochs=50, + batch_size=200, + initial_lr=0.001, + final_lr=0.0001, + nesterov_momentum=None, + validation_split=0.25, + early_stopping=True, + scale_inputs=True, + shuffle_labels=False, + limit_samplesize=None, + verbose="some", + ): + + """ + Trains the network. + + Parameters + ---------- + method : str + The inference method used for training. Allowed values are 'alice', 'alices', 'carl', 'cascal', 'rascal', + and 'rolr'. + + x : ndarray or str + Path to an unweighted sample of observations, as saved by the `madminer.sampling.SampleAugmenter` functions. + Required for all inference methods. + + y : ndarray or str + Class labels (0 = numeerator, 1 = denominator), or filename of a pickled numpy array. + + theta0 : ndarray or str + Numerator parameter point, or filename of a pickled numpy array. + + theta1 : ndarray or str + Denominator parameter point, or filename of a pickled numpy array. + + r_xz : ndarray or str or None, optional + Joint likelihood ratio, or filename of a pickled numpy array. Default value: None. + + t_xz0 : ndarray or str or None, optional + Joint scores at theta0, or filename of a pickled numpy array. Default value: None. + + t_xz1 : ndarray or str or None, optional + Joint scores at theta1, or filename of a pickled numpy array. Default value: None. + + alpha : float, optional + Hyperparameter weighting the score error in the loss function of the 'alices', 'rascal', and 'cascal' + methods. Default value: 1. + + optimizer : {"adam", "amsgrad", "sgd"}, optional + Optimization algorithm. Default value: "amsgrad". + + n_epochs : int, optional + Number of epochs. Default value: 50. + + batch_size : int, optional + Batch size. Default value: 200. + + initial_lr : float, optional + Learning rate during the first epoch, after which it exponentially decays to final_lr. Default value: + 0.001. + + final_lr : float, optional + Learning rate during the last epoch. Default value: 0.0001. + + nesterov_momentum : float or None, optional + If trainer is "sgd", sets the Nesterov momentum. Default value: None. + + validation_split : float or None, optional + Fraction of samples used for validation and early stopping (if early_stopping is True). If None, the entire + sample is used for training and early stopping is deactivated. Default value: 0.25. + + early_stopping : bool, optional + Activates early stopping based on the validation loss (only if validation_split is not None). Default value: + True. + + scale_inputs : bool, optional + Scale the observables to zero mean and unit variance. Default value: True. + + shuffle_labels : bool, optional + If True, the labels (`y`, `r_xz`, `t_xz`) are shuffled, while the observations (`x`) remain in their + normal order. This serves as a closure test, in particular as cross-check against overfitting: an estimator + trained with shuffle_labels=True should predict to likelihood ratios around 1 and scores around 0. + + limit_samplesize : int or None, optional + If not None, only this number of samples (events) is used to train the estimator. Default value: None. + + verbose : {"all", "many", "some", "few", "none}, optional + Determines verbosity of training. Default value: "some". + + Returns + ------- + None + + """ + + logger.info("Starting training") + logger.info(" Method: %s", method) + if method in ["cascal", "rascal", "alices"]: + logger.info(" alpha: %s", alpha) + logger.info(" Batch size: %s", batch_size) + logger.info(" Optimizer: %s", optimizer) + logger.info(" Epochs: %s", n_epochs) + logger.info(" Learning rate: %s initially, decaying to %s", initial_lr, final_lr) + if optimizer == "sgd": + logger.info(" Nesterov momentum: %s", nesterov_momentum) + logger.info(" Validation split: %s", validation_split) + logger.info(" Early stopping: %s", early_stopping) + logger.info(" Scale inputs: %s", scale_inputs) + logger.info(" Shuffle labels %s", shuffle_labels) + if limit_samplesize is None: + logger.info(" Samples: all") + else: + logger.info(" Samples: %s", limit_samplesize) + + # Load training data + logger.info("Loading training data") + theta0 = load_and_check(theta0) + theta1 = load_and_check(theta1) + x = load_and_check(x) + y = load_and_check(y) + r_xz = load_and_check(r_xz) + t_xz0 = load_and_check(t_xz0) + t_xz1 = load_and_check(t_xz1) + + self._check_required_data(method, r_xz, t_xz0, t_xz1) + + # Infer dimensions of problem + n_samples = x.shape[0] + n_observables = x.shape[1] + n_parameters = theta0.shape[1] + logger.info("Found %s samples with %s parameters and %s observables", n_samples, n_parameters, n_observables) + + # Limit sample size + if limit_samplesize is not None and limit_samplesize < n_samples: + logger.info("Only using %s of %s training samples", limit_samplesize, n_samples) + x, theta0, theta1, y, r_xz, t_xz0, t_xz1 = restrict_samplesize( + limit_samplesize, x, theta0, theta1, y, r_xz, t_xz0, t_xz1 + ) + + # Scale features + if scale_inputs: + logger.info("Rescaling inputs") + self._initialize_input_transform(x) + x = self._transform_inputs(x) + else: + self._initialize_input_transform(x, False) + + # Shuffle labels + if shuffle_labels: + logger.info("Shuffling labels") + y, r_xz, t_xz0, t_xz1 = shuffle(y, r_xz, t_xz0, t_xz1) + + # Features if self.features is not None: x = x[:, self.features] + logger.info("Only using %s of %s observables", x.shape[1], n_observables) + n_observables = x.shape[1] - # SALLY evaluation - if self.method not in ["sally", "sallino"]: - raise NotImplementedError("Score evaluation only implemented for methods SALLY and SALLINO.") + # Check consistency of input with model + if self.n_observables is None: + self.n_observables = n_observables + if self.n_parameters is None: + self.n_parameters = n_parameters - logger.debug("Starting score evaluation") + if n_parameters != self.n_parameters: + raise RuntimeError( + "Number of parameters does not match model: {} vs {}".format(n_parameters, self.n_parameters) + ) + if n_observables != self.n_observables: + raise RuntimeError( + "Number of observables does not match model: {} vs {}".format(n_observables, self.n_observables) + ) + + # Data + data = self._package_training_data(method, x, theta0, theta1, y, r_xz, t_xz0, t_xz1) - all_t_hat = evaluate_local_score_model(model=self.model, xs=x) - return all_t_hat + # Create model + if self.model is None: + logger.info("Creating model", method) + self._create_model() + + # Losses + loss_functions, loss_labels, loss_weights = get_loss(method + "2", alpha) - def evaluate_log_likelihood(self, x, theta0_filename=None, test_all_combinations=True, evaluate_score=False): + # Optimizer + opt, opt_kwargs = get_optimizer(optimizer, nesterov_momentum) + # Train model + logger.info("Training model") + trainer = DoubleParameterizedRatioTrainer(self.model) + result = trainer.train( + data=data, + loss_functions=loss_functions, + loss_weights=loss_weights, + loss_labels=loss_labels, + epochs=n_epochs, + batch_size=batch_size, + optimizer=opt, + optimizer_kwargs=opt_kwargs, + initial_lr=initial_lr, + final_lr=final_lr, + validation_split=validation_split, + early_stopping=early_stopping, + verbose=verbose, + ) + return result + + def evaluate_log_likelihood_ratio(self, x, theta0, theta1, test_all_combinations=True, evaluate_score=False): """ - Evaluates a trained estimator of the log likelihood. + Evaluates the log likelihood ratio as a function of the observation x, the numerator hypothesis theta0, and + the denominator hypothesis theta1. Parameters ---------- x : str or ndarray - Sample of observations, or path to numpy file with observations, as saved by the - `madminer.sampling.SampleAugmenter` functions. + Observations or filename of a pickled numpy array. - theta0_filename : str or None, optional - Path to an unweighted sample of numerator parameters, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required if the estimator was trained with the 'alice', 'alice2', 'alices', 'alices2', 'carl', - 'carl2', 'nde', 'rascal', 'rascal2', 'rolr', 'rolr2', or 'scandal' method. Default value: None. + theta0 : ndarray or str + Numerator parameter points or filename of a pickled numpy array. + + theta1 : ndarray or str + Denominator parameter points or filename of a pickled numpy array. test_all_combinations : bool, optional - If method is not 'sally' and not 'sallino': If False, the number of samples in the observable and theta + If False, the number of samples in the observable and theta files has to match, and the likelihood ratio is evaluated only for the combinations `r(x_i | theta0_i, theta1_i)`. If True, `r(x_i | theta0_j, theta1_j)` for all pairwise combinations `i, j` are evaluated. Default value: True. evaluate_score : bool, optional - If method is not 'sally' and not 'sallino', this sets whether in addition to the likelihood ratio the score - is evaluated. Default value: False. + Sets whether in addition to the likelihood ratio the score is evaluated. Default value: False. Returns ------- + log_likelihood_ratio : ndarray + The estimated log likelihood ratio. If test_all_combinations is True, the result has shape + `(n_thetas, n_x)`. Otherwise, it has shape `(n_samples,)`. - log_likelihood : ndarray - The estimated log likelihood. If test_all_combinations is True, the result has shape `(n_thetas, n_x)`. - Otherwise, it has shape `(n_samples,)`. + score0 : ndarray or None + None if evaluate_score is False. Otherwise the derived estimated score at `theta0`. If test_all_combinations + is True, the result has shape `(n_thetas, n_x, n_parameters)`. Otherwise, it has shape + `(n_samples, n_parameters)`. - score_theta0 : ndarray or None - None if - evaluate_score is False. Otherwise the derived estimated score at `theta0`. If test_all_combinations is - True, the result has shape `(n_thetas, n_x, n_parameters)`. Otherwise, it has shape + score1 : ndarray or None + None if evaluate_score is False. Otherwise the derived estimated score at `theta1`. If test_all_combinations + is True, the result has shape `(n_thetas, n_x, n_parameters)`. Otherwise, it has shape `(n_samples, n_parameters)`. """ - if self.model is None: raise ValueError("No model -- train or load model before evaluating it!") # Load training data logger.debug("Loading evaluation data") - thetas = load_and_check(theta0_filename) - if isinstance(x, six.string_types): - x = load_and_check(x) + x = load_and_check(x) + theta0 = load_and_check(theta0) + theta1 = load_and_check(theta1) # Scale observables x = self._transform_inputs(x) - # Restrict featuers + # Restrict features if self.features is not None: x = x[:, self.features] - if self.method_type != "nde": - raise RuntimeError("Likelihood estimation only possible for methods NDE and SCANDAL") + # Balance thetas + if len(theta1) > len(theta0): + theta0 = [theta0[i % len(theta0)] for i in range(len(theta1))] + elif len(theta1) < len(theta0): + theta1 = [theta1[i % len(theta1)] for i in range(len(theta0))] - # Evaluation for all other methods - all_log_p_hat = [] - all_t_hat = [] + all_log_r_hat = [] + all_t_hat0 = [] + all_t_hat1 = [] if test_all_combinations: logger.debug("Starting ratio evaluation for all combinations") - for i, theta in enumerate(thetas): - logger.debug("Starting log likelihood evaluation for theta %s / %s: %s", i + 1, len(thetas), theta) + for i, (this_theta0, this_theta1) in enumerate(zip(theta0, theta1)): + logger.debug( + "Starting ratio evaluation for thetas %s / %s: %s vs %s", + i + 1, + len(theta0), + this_theta0, + this_theta1, + ) + _, log_r_hat, t_hat0, t_hat1 = evaluate_ratio_model( + model=self.model, + method_type="double_parameterized_ratio", + theta0s=[this_theta0], + theta1s=[this_theta1], + xs=x, + evaluate_score=evaluate_score, + ) + + all_log_r_hat.append(log_r_hat) + all_t_hat0.append(t_hat0) + all_t_hat1.append(t_hat1) + + all_log_r_hat = np.array(all_log_r_hat) + all_t_hat0 = np.array(all_t_hat0) + all_t_hat1 = np.array(all_t_hat1) + + else: + logger.debug("Starting ratio evaluation") + _, all_log_r_hat, all_t_hat0, all_t_hat1 = evaluate_ratio_model( + model=self.model, + method_type="double_parameterized_ratio", + theta0s=theta0, + theta1s=theta1, + xs=x, + evaluate_score=evaluate_score, + ) + + logger.debug("Evaluation done") + return all_log_r_hat, all_t_hat0, all_t_hat1 + + def evaluate_log_likelihood(self, *args, **kwargs): + raise TheresAGoodReasonThisDoesntWork( + "This estimator can only estimate likelihood ratios, not the likelihood " "itself!" + ) + + def evaluate_score(self, *args, **kwargs): + raise NotImplementedError("Please use evaluate_log_likelihood_ratio(evaluate_score=True).") + + def calculate_fisher_information(self, *args, **kwargs): + raise NotImplementedError( + "Please use evaluate_log_likelihood_ratio(evaluate_score=True) and calculate the " + "Fisher information manually." + ) + + def evaluate(self, *args, **kwargs): + return self.evaluate_log_likelihood_ratio(*args, **kwargs) + + def _create_model(self): + self.model = DenseDoublyParameterizedRatioModel( + n_observables=self.n_observables, + n_parameters=self.n_parameters, + n_hidden=self.n_hidden, + activation=self.activation, + ) + + @staticmethod + def _check_required_data(method, r_xz, t_xz0, t_xz1): + if method in ["cascal", "alices", "rascal"] and (t_xz0 is None or t_xz1 is None): + raise RuntimeError("Method {} requires joint score information".format(method)) + if method in ["rolr", "alice", "alices", "rascal"] and r_xz is None: + raise RuntimeError("Method {} requires joint likelihood ratio information".format(method)) + + @staticmethod + def _package_training_data(method, x, theta0, theta1, y, r_xz, t_xz0, t_xz1): + data = OrderedDict() + data["x"] = x + data["theta0"] = theta0 + data["theta1"] = theta1 + data["y"] = y + if method in ["rolr", "alice", "alices", "rascal"]: + data["r_xz"] = r_xz + if method in ["cascal", "alices", "rascal"]: + data["t_xz0"] = t_xz0 + data["t_xz1"] = t_xz1 + return data + + def _wrap_settings(self): + settings = super(DoubleParameterizedRatioEstimator, self)._wrap_settings() + settings["estimator_type"] = "double_parameterized_ratio" + return settings + + def _unwrap_settings(self, settings): + super(DoubleParameterizedRatioEstimator, self)._unwrap_settings(settings) + + estimator_type = str(settings["estimator_type"]) + if estimator_type != "double_parameterized_ratio": + raise RuntimeError("Saved model is an incompatible estimator type {}.".format(estimator_type)) + + +class ScoreEstimator(Estimator): + """ A neural estimator of the score evaluated at a fixed reference hypothesis as a function of the + observation x. + + Parameters + ---------- + features : list of int or None, optional + Indices of observables (features) that are used as input to the neural networks. If None, all observables + are used. Default value: None. + + n_hidden : tuple of int, optional + Units in each hidden layer in the neural networks. If method is 'nde' or 'scandal', this refers to the + setup of each individual MADE layer. Default value: (100, 100). + + activation : {'tanh', 'sigmoid', 'relu'}, optional + Activation function. Default value: 'tanh'. + + """ + + def __init__(self, features=None, n_components=1, n_mades=5, n_hidden=(100,), activation="tanh", batch_norm=None): + super(ScoreEstimator, self).__init__(features, n_hidden, activation) + + self.nuisance_profile_matrix = None + self.nuisance_project_matrix = None + self.nuisance_mode_default = "keep" + + def train( + self, + method, + x, + t_xz, + optimizer="amsgrad", + n_epochs=50, + batch_size=200, + initial_lr=0.001, + final_lr=0.0001, + nesterov_momentum=None, + validation_split=0.25, + early_stopping=True, + scale_inputs=True, + shuffle_labels=False, + limit_samplesize=None, + verbose="some", + ): + + """ + Trains the network. + + Parameters + ---------- + method : str + The inference method used for training. Currently values are 'sally' and 'sallino', but at the training + stage they are identical. So right now it doesn't matter which one you use. + + x : ndarray or str + Path to an unweighted sample of observations, as saved by the `madminer.sampling.SampleAugmenter` functions. + Required for all inference methods. + + t_xz : ndarray or str + Joint scores at the reference hypothesis, or filename of a pickled numpy array. + + optimizer : {"adam", "amsgrad", "sgd"}, optional + Optimization algorithm. Default value: "amsgrad". + + n_epochs : int, optional + Number of epochs. Default value: 50. + + batch_size : int, optional + Batch size. Default value: 200. + + initial_lr : float, optional + Learning rate during the first epoch, after which it exponentially decays to final_lr. Default value: + 0.001. + + final_lr : float, optional + Learning rate during the last epoch. Default value: 0.0001. + + nesterov_momentum : float or None, optional + If trainer is "sgd", sets the Nesterov momentum. Default value: None. + + validation_split : float or None, optional + Fraction of samples used for validation and early stopping (if early_stopping is True). If None, the entire + sample is used for training and early stopping is deactivated. Default value: 0.25. + + early_stopping : bool, optional + Activates early stopping based on the validation loss (only if validation_split is not None). Default value: + True. + + scale_inputs : bool, optional + Scale the observables to zero mean and unit variance. Default value: True. + + shuffle_labels : bool, optional + If True, the labels (`y`, `r_xz`, `t_xz`) are shuffled, while the observations (`x`) remain in their + normal order. This serves as a closure test, in particular as cross-check against overfitting: an estimator + trained with shuffle_labels=True should predict to likelihood ratios around 1 and scores around 0. + + limit_samplesize : int or None, optional + If not None, only this number of samples (events) is used to train the estimator. Default value: None. + + verbose : {"all", "many", "some", "few", "none}, optional + Determines verbosity of training. Default value: "some". + + Returns + ------- + None + + """ + + if method not in ["sally", "sallino"]: + logger.warning("Method %s not allowed for score estimators. Using 'sally' instead.", method) + method = "sally" + + logger.info("Starting training") + logger.info(" Batch size: %s", batch_size) + logger.info(" Optimizer: %s", optimizer) + logger.info(" Epochs: %s", n_epochs) + logger.info(" Learning rate: %s initially, decaying to %s", initial_lr, final_lr) + if optimizer == "sgd": + logger.info(" Nesterov momentum: %s", nesterov_momentum) + logger.info(" Validation split: %s", validation_split) + logger.info(" Early stopping: %s", early_stopping) + logger.info(" Scale inputs: %s", scale_inputs) + logger.info(" Shuffle labels %s", shuffle_labels) + if limit_samplesize is None: + logger.info(" Samples: all") + else: + logger.info(" Samples: %s", limit_samplesize) + + # Load training data + logger.info("Loading training data") + x = load_and_check(x) + t_xz = load_and_check(t_xz) + + # Infer dimensions of problem + n_samples = x.shape[0] + n_observables = x.shape[1] + n_parameters = t_xz.shape[1] + logger.info("Found %s samples with %s parameters and %s observables", n_samples, n_parameters, n_observables) + + # Limit sample size + if limit_samplesize is not None and limit_samplesize < n_samples: + logger.info("Only using %s of %s training samples", limit_samplesize, n_samples) + x, t_xz = restrict_samplesize(limit_samplesize, x, t_xz) + + # Scale features + if scale_inputs: + logger.info("Rescaling inputs") + self._initialize_input_transform(x) + x = self._transform_inputs(x) + else: + self._initialize_input_transform(x, False) + + # Shuffle labels + if shuffle_labels: + logger.info("Shuffling labels") + t_xz = shuffle(t_xz) + + # Features + if self.features is not None: + x = x[:, self.features] + logger.info("Only using %s of %s observables", x.shape[1], n_observables) + n_observables = x.shape[1] + + # Check consistency of input with model + if self.n_observables is None: + self.n_observables = n_observables + if self.n_parameters is None: + self.n_parameters = n_parameters + + if n_parameters != self.n_parameters: + raise RuntimeError( + "Number of parameters does not match model: {} vs {}".format(n_parameters, self.n_parameters) + ) + if n_observables != self.n_observables: + raise RuntimeError( + "Number of observables does not match model: {} vs {}".format(n_observables, self.n_observables) + ) + + # Data + data = self._package_training_data(x, t_xz) + + # Create model + if self.model is None: + logger.info("Creating model") + self._create_model() + + # Losses + loss_functions, loss_labels, loss_weights = get_loss(method, None) + + # Optimizer + opt, opt_kwargs = get_optimizer(optimizer, nesterov_momentum) + + # Train model + logger.info("Training model") + trainer = LocalScoreTrainer(self.model) + result = trainer.train( + data=data, + loss_functions=loss_functions, + loss_weights=loss_weights, + loss_labels=loss_labels, + epochs=n_epochs, + batch_size=batch_size, + optimizer=opt, + optimizer_kwargs=opt_kwargs, + initial_lr=initial_lr, + final_lr=final_lr, + validation_split=validation_split, + early_stopping=early_stopping, + verbose=verbose, + ) + return result + + def set_nuisance(self, fisher_information, parameters_of_interest): + """ + Prepares the calculation of profiled scores, see https://arxiv.org/pdf/1903.01473.pdf. + + Parameters + ---------- + fisher_information : ndarray + Fisher informatioin with shape `(n_parameters, n_parameters)`. + + parameters_of_interest : list of int + List of int, with 0 <= remaining_compoinents[i] < n_parameters. Denotes which parameters are kept in the + profiling, and their new order. + + Returns + ------- + None + + """ + if fisher_information.shape != (self.n_parameters, self.n_parameters): + raise ValueError( + "Fisher information has wrong shape {}, expected {}".format( + fisher_information.shape, (self.n_parameters, self.n_parameters) + ) + ) + + n_parameters_of_interest = len(parameters_of_interest) + + # Separate Fisher information parts + nuisance_parameters, information_phys, information_mix, information_nuisance = separate_information_blocks( + fisher_information, parameters_of_interest + ) + + # Calculate projection matrix + self.nuisance_project_matrix = np.zeros((n_parameters_of_interest, self.n_parameters)) # (n_phys, n_all) + for theta_new, theta_old in enumerate(parameters_of_interest): + self.nuisance_project_matrix[theta_new, theta_old] = 1.0 + + logger.debug("Nuisance projection matrix:/n%s", self.nuisance_project_matrix) + + # Calculate profiling matrix + inverse_information_nuisance = np.linalg.inv(information_nuisance) # (n_nuisance, n_nuisance) + profiling_matrix = -information_mix.T.dot(inverse_information_nuisance) # (n_phys, n_nuisance) + + self.nuisance_profile_matrix = np.copy(self.nuisance_project_matrix) # (n_phys, n_all) + for theta_new, theta_old in enumerate(parameters_of_interest): + for nuis_new, nuis_old in enumerate(nuisance_parameters): + self.nuisance_profile_matrix[theta_new, nuis_old] += profiling_matrix[theta_new, nuis_new] + + logger.debug("Nuisance profiling matrix:/n%s", self.nuisance_project_matrix) + + def evaluate_score(self, x, nuisance_mode="auto"): + """ + Evaluates the score. + + Parameters + ---------- + x : str or ndarray + Observations, or filename of a pickled numpy array. + + nuisance_mode : {"auto", "keep", "profile", "project"} + Decides how nuisance parameters are treated. If nuisance_mode is "auto", the returned score is the (n+k)- + dimensional score in the space of n parameters of interest and k nuisance parameters if `set_profiling` + has not been called, and the n-dimensional profiled score in the space of the parameters of interest + if it has been called. For "keep", the returned score is always (n+k)-dimensional. For "profile", it is + the n-dimensional profiled score. For "project", it is the n-dimensional projected score, i.e. ignoring + the nuisance parameters. + + Returns + ------- + score : ndarray + Estimated score with shape `(n_observations, n_parameters)`. + """ + + if self.model is None: + raise ValueError("No model -- train or load model before evaluating it!") + + if nuisance_mode == "auto": + logger.debug("Using nuisance mode %s", self.nuisance_mode_default) + nuisance_mode = self.nuisance_mode_default + + # Load training data + logger.debug("Loading evaluation data") + x = load_and_check(x) + + # Scale observables + x = self._transform_inputs(x) + + # Restrict featuers + if self.features is not None: + x = x[:, self.features] + + # Evaluation + logger.debug("Starting score evaluation") + t_hat = evaluate_local_score_model(model=self.model, xs=x) + + # Treatment of nuisance paramters + if nuisance_mode == "keep": + logging.debug("Keeping nuisance parameter score") - log_p_hat, t_hat = evaluate_flow_model( - model=self.model, thetas=[theta], xs=x, evaluate_score=evaluate_score + elif nuisance_mode == "project": + if self.nuisance_project_matrix is None: + raise ValueError( + "evaluate_score() was called with nuisance_mode = project, but nuisance parameters " + "have not been set up yet. Please call set_nuisance() first!" ) + logging.debug("Projecting nuisance parameter score") + t_hat = np.einsum("ij,xj->xi", self.nuisance_project_matrix, t_hat) + + elif nuisance_mode == "profile": + if self.nuisance_profile_matrix is None: + raise ValueError( + "evaluate_score() was called with nuisance_mode = profile, but nuisance parameters " + "have not been set up yet. Please call set_nuisance() first!" + ) + logging.debug("Profiling nuisance parameter score") + t_hat = np.einsum("ij,xj->xi", self.nuisance_profile_matrix, t_hat) - all_log_p_hat.append(log_p_hat) - all_t_hat.append(t_hat) + else: + raise ValueError("Unknown nuisance_mode {}".format(nuisance_mode)) - all_log_p_hat = np.array(all_log_p_hat) - all_t_hat = np.array(all_t_hat) + return t_hat - else: - logger.debug("Starting log likelihood evaluation") + def evaluate_log_likelihood(self, *args, **kwargs): + raise TheresAGoodReasonThisDoesntWork("This estimator can only estimate the score, not the likelihood!") - all_log_p_hat, all_t_hat = evaluate_flow_model( - model=self.model, thetas=thetas, xs=x, evaluate_score=evaluate_score - ) + def evaluate_log_likelihood_ratio(self, *args, **kwargs): + raise TheresAGoodReasonThisDoesntWork("This estimator can only estimate the score, not the likelihood ratio!") - logger.debug("Evaluation done") - return all_log_p_hat, all_t_hat + def evaluate(self, *args, **kwargs): + return self.evaluate_score(*args, **kwargs) def calculate_fisher_information(self, x, weights=None, n_events=1, sum_events=True): - """ Calculates the expected Fisher information matrix based on the kinematic information in a given number of - events. Currently only supported for estimators trained with `method='sally'` or `method='sallino'`. + events. Parameters ---------- x : str or ndarray - Sample of observations, or path to numpy file with observations, as saved by the - `madminer.sampling.SampleAugmenter` functions. Note that this sample has to be sampled from the reference - parameter where the score is estimated with the SALLY / SALLINO estimator! + Sample of observations, or path to numpy file with observations. Note that this sample has to be sampled + from the reference parameter where the score is estimated with the SALLY / SALLINO estimator. weights : None or ndarray, optional Weights for the observations. If None, all events are taken to have equal weight. Default value: None. - + n_events : float, optional Expected number of events for which the kinematic Fisher information should be calculated. Default value: 1. @@ -771,14 +1372,12 @@ def calculate_fisher_information(self, x, weights=None, n_events=1, sum_events=T sum_events is False or `(n_parameters, n_parameters)` if sum_events is True. """ - if self.model is None: raise ValueError("No model -- train or load model before evaluating it!") # Load training data logger.debug("Loading evaluation data") - if isinstance(x, six.string_types): - x = load_and_check(x) + x = load_and_check(x) n_samples = x.shape[0] # Scale observables @@ -789,12 +1388,8 @@ def calculate_fisher_information(self, x, weights=None, n_events=1, sum_events=T x = x[:, self.features] # Estimate scores - if self.method in ["sally", "sallino"]: - logger.debug("Starting score evaluation") - - t_hats = evaluate_local_score_model(model=self.model, xs=x) - else: - raise NotImplementedError("Fisher information calculation only implemented for SALLY estimators") + logger.debug("Starting score evaluation") + t_hats = evaluate_local_score_model(model=self.model, xs=x) # Weights if weights is None: @@ -814,19 +1409,194 @@ def calculate_fisher_information(self, x, weights=None, n_events=1, sum_events=T return fisher_information def save(self, filename, save_model=False): + super(ScoreEstimator, self).save(filename, save_model) + + # Also save Fisher information information for profiling / projections + if self.nuisance_profile_matrix is not None and self.nuisance_project_matrix is not None: + logger.debug( + "Saving nuisance profiling / projection information to %s_nuisance_profile_matrix.npy and " + "%s_nuisance_project_matrix.npy", + filename, + filename, + ) + np.save(filename + "_nuisance_profile_matrix.npy", self.nuisance_profile_matrix) + np.save(filename + "_nuisance_project_matrix.npy", self.nuisance_project_matrix) + + def load(self, filename): + super(ScoreEstimator, self).load(filename) + + # Load scaling + try: + self.nuisance_profile_matrix = np.load(filename + "_nuisance_profile_matrix.npy") + self.nuisance_project_matrix = np.load(filename + "_nuisance_project_matrix.npy") + logger.debug( + " Found nuisance profiling / projection matrices:\nProfiling:\n%s\nProjection:\n%s", + self.nuisance_profile_matrix, + self.nuisance_project_matrix, + ) + except: + logger.debug("Did not find nuisance profiling / projection setup in %s", filename) + self.nuisance_profile_matrix = None + self.nuisance_project_matrix = None + + def _create_model(self): + self.model = DenseLocalScoreModel( + n_observables=self.n_observables, + n_parameters=self.n_parameters, + n_hidden=self.n_hidden, + activation=self.activation, + ) + + @staticmethod + def _package_training_data(x, t_xz): + data = OrderedDict() + data["x"] = x + data["t_xz"] = t_xz + return data + + def _wrap_settings(self): + settings = super(ScoreEstimator, self)._wrap_settings() + settings["estimator_type"] = "score" + settings["estimator_type"] = "score" + settings["nuisance_mode_default"] = self.nuisance_mode_default + return settings + + def _unwrap_settings(self, settings): + super(ScoreEstimator, self)._unwrap_settings(settings) + + estimator_type = str(settings["estimator_type"]) + if estimator_type != "score": + raise RuntimeError("Saved model is an incompatible estimator type {}.".format(estimator_type)) + + try: + self.nuisance_mode_default = str(settings["nuisance_mode_default"]) + except KeyError: + self.nuisance_mode_default = "keep" + logger.warning("Did not find entry nuisance_mode_default in saved model, using default 'keep'.") + + +class LikelihoodEstimator(Estimator): + """ A neural estimator of the density or likelihood evaluated at a reference hypothesis as a function + of the observation x. + + Parameters + ---------- + features : list of int or None, optional + Indices of observables (features) that are used as input to the neural networks. If None, all observables + are used. Default value: None. + + n_components : int, optional + The number of Gaussian base components in a MADE MoG. If 1, a plain MADE is used. + Default value: 1. + + n_mades : int, optional + The number of MADE layers. Default value: 3. + + + n_hidden : tuple of int, optional + Units in each hidden layer in the neural networks. If method is 'nde' or 'scandal', this refers to the + setup of each individual MADE layer. Default value: (100, 100). + + activation : {'tanh', 'sigmoid', 'relu'}, optional + Activation function. Default value: 'tanh'. + + batch_norm : None or floar, optional + If not None, batch normalization is used, where this value sets the alpha parameter in the calculation + of the running average of the mean and variance. Default value: None. + + + """ + + def __init__(self, features=None, n_components=1, n_mades=5, n_hidden=(100,), activation="tanh", batch_norm=None): + super(LikelihoodEstimator, self).__init__(features, n_hidden, activation) + + self.n_components = n_components + self.n_mades = n_mades + self.batch_norm = batch_norm + + def train( + self, + method, + x, + theta, + t_xz=None, + alpha=1.0, + optimizer="amsgrad", + n_epochs=50, + batch_size=200, + initial_lr=0.001, + final_lr=0.0001, + nesterov_momentum=None, + validation_split=0.25, + early_stopping=True, + scale_inputs=True, + shuffle_labels=False, + limit_samplesize=None, + verbose="some", + ): """ - Saves the trained model to four files: a JSON file with the settings, a pickled pyTorch state dict - file, and numpy files for the mean and variance of the inputs (used for input scaling). + Trains the network. Parameters ---------- - filename : str - Path to the files. '_settings.json' and '_state_dict.pl' will be added. + method : str + The inference method used for training. Allowed values are 'nde' and 'scandal'. - save_model : bool, optional - If True, the whole model is saved in addition to the state dict. This is not necessary for loading it - again with MLForge.load(), but can be useful for debugging, for instance to plot the computational graph. + x : ndarray or str + Path to an unweighted sample of observations, as saved by the `madminer.sampling.SampleAugmenter` functions. + Required for all inference methods. + + theta : ndarray or str + Numerator parameter point, or filename of a pickled numpy array. + + t_xz : ndarray or str or None, optional + Joint scores at theta, or filename of a pickled numpy array. Default value: None. + + alpha : float, optional + Hyperparameter weighting the score error in the loss function of the 'alices', 'rascal', and 'cascal' + methods. Default value: 1. + + optimizer : {"adam", "amsgrad", "sgd"}, optional + Optimization algorithm. Default value: "amsgrad". + + n_epochs : int, optional + Number of epochs. Default value: 50. + + batch_size : int, optional + Batch size. Default value: 200. + + initial_lr : float, optional + Learning rate during the first epoch, after which it exponentially decays to final_lr. Default value: + 0.001. + + final_lr : float, optional + Learning rate during the last epoch. Default value: 0.0001. + + nesterov_momentum : float or None, optional + If trainer is "sgd", sets the Nesterov momentum. Default value: None. + + validation_split : float or None, optional + Fraction of samples used for validation and early stopping (if early_stopping is True). If None, the entire + sample is used for training and early stopping is deactivated. Default value: 0.25. + + early_stopping : bool, optional + Activates early stopping based on the validation loss (only if validation_split is not None). Default value: + True. + + scale_inputs : bool, optional + Scale the observables to zero mean and unit variance. Default value: True. + + shuffle_labels : bool, optional + If True, the labels (`y`, `r_xz`, `t_xz`) are shuffled, while the observations (`x`) remain in their + normal order. This serves as a closure test, in particular as cross-check against overfitting: an estimator + trained with shuffle_labels=True should predict to likelihood ratios around 1 and scores around 0. + + limit_samplesize : int or None, optional + If not None, only this number of samples (events) is used to train the estimator. Default value: None. + + verbose : {"all", "many", "some", "few", "none}, optional + Determines verbosity of training. Default value: "some". Returns ------- @@ -834,238 +1604,368 @@ def save(self, filename, save_model=False): """ - if self.model is None: - raise ValueError("No model -- train or load model before saving!") + logger.info("Starting training") + logger.info(" Method: %s", method) + if method == "scandal": + logger.info(" alpha: %s", alpha) + logger.info(" Batch size: %s", batch_size) + logger.info(" Optimizer: %s", optimizer) + logger.info(" Epochs: %s", n_epochs) + logger.info(" Learning rate: %s initially, decaying to %s", initial_lr, final_lr) + if optimizer == "sgd": + logger.info(" Nesterov momentum: %s", nesterov_momentum) + logger.info(" Validation split: %s", validation_split) + logger.info(" Early stopping: %s", early_stopping) + logger.info(" Scale inputs: %s", scale_inputs) + logger.info(" Shuffle labels %s", shuffle_labels) + if limit_samplesize is None: + logger.info(" Samples: all") + else: + logger.info(" Samples: %s", limit_samplesize) + + # Load training data + logger.info("Loading training data") + theta = load_and_check(theta) + x = load_and_check(x) + t_xz = load_and_check(t_xz) + + self._check_required_data(method, t_xz) + + # Infer dimensions of problem + n_samples = x.shape[0] + n_observables = x.shape[1] + n_parameters = theta.shape[1] + logger.info("Found %s samples with %s parameters and %s observables", n_samples, n_parameters, n_observables) + + # Limit sample size + if limit_samplesize is not None and limit_samplesize < n_samples: + logger.info("Only using %s of %s training samples", limit_samplesize, n_samples) + x, theta, t_xz = restrict_samplesize(limit_samplesize, x, theta, t_xz) + + # Scale features + if scale_inputs: + logger.info("Rescaling inputs") + self._initialize_input_transform(x) + x = self._transform_inputs(x) + else: + self._initialize_input_transform(x, False) + + # Shuffle labels + if shuffle_labels: + logger.info("Shuffling labels") + t_xz = shuffle(t_xz) + + # Features + if self.features is not None: + x = x[:, self.features] + logger.info("Only using %s of %s observables", x.shape[1], n_observables) + n_observables = x.shape[1] + + # Check consistency of input with model + if self.n_observables is None: + self.n_observables = n_observables + if self.n_parameters is None: + self.n_parameters = n_parameters + + if n_parameters != self.n_parameters: + raise RuntimeError( + "Number of parameters does not match model: {} vs {}".format(n_parameters, self.n_parameters) + ) + if n_observables != self.n_observables: + raise RuntimeError( + "Number of observables does not match model: {} vs {}".format(n_observables, self.n_observables) + ) + + # Data + data = self._package_training_data(method, x, theta, t_xz) + + # Create model + if self.model is None: + logger.info("Creating model", method) + self._create_model() + + # Losses + loss_functions, loss_labels, loss_weights = get_loss(method, alpha) + + # Optimizer + opt, opt_kwargs = get_optimizer(optimizer, nesterov_momentum) + + # Train model + logger.info("Training model") + trainer = FlowTrainer(self.model) + result = trainer.train( + data=data, + loss_functions=loss_functions, + loss_weights=loss_weights, + loss_labels=loss_labels, + epochs=n_epochs, + batch_size=batch_size, + optimizer=opt, + optimizer_kwargs=opt_kwargs, + initial_lr=initial_lr, + final_lr=final_lr, + validation_split=validation_split, + early_stopping=early_stopping, + verbose=verbose, + ) + return result + + def evaluate_log_likelihood(self, x, theta, test_all_combinations=True, evaluate_score=False): + + """ + Evaluates the log likelihood as a function of the observation x and the parameter point theta. + + Parameters + ---------- + x : ndarray or str + Sample of observations, or path to numpy file with observations. + + theta : ndarray or str + Parameter points, or path to numpy file with parameter points. + + test_all_combinations : bool, optional + If method is not 'sally' and not 'sallino': If False, the number of samples in the observable and theta + files has to match, and the likelihood ratio is evaluated only for the combinations + `r(x_i | theta0_i, theta1_i)`. If True, `r(x_i | theta0_j, theta1_j)` for all pairwise combinations `i, j` + are evaluated. Default value: True. + + evaluate_score : bool, optional + If method is not 'sally' and not 'sallino', this sets whether in addition to the likelihood ratio the score + is evaluated. Default value: False. + + Returns + ------- + + log_likelihood : ndarray + The estimated log likelihood. If test_all_combinations is True, the result has shape `(n_thetas, n_x)`. + Otherwise, it has shape `(n_samples,)`. + + score : ndarray or None + None if + evaluate_score is False. Otherwise the derived estimated score at `theta`. If test_all_combinations is + True, the result has shape `(n_thetas, n_x, n_parameters)`. Otherwise, it has shape + `(n_samples, n_parameters)`. + + """ + + if self.model is None: + raise ValueError("No model -- train or load model before evaluating it!") + + # Load training data + logger.debug("Loading evaluation data") + theta = load_and_check(theta) + x = load_and_check(x) + + # Scale observables + x = self._transform_inputs(x) + + # Restrict featuers + if self.features is not None: + x = x[:, self.features] + + # Evaluation for all other methods + all_log_p_hat = [] + all_t_hat = [] + + if test_all_combinations: + logger.debug("Starting ratio evaluation for all combinations") - # Check paths - create_missing_folders([os.path.dirname(filename)]) + for i, this_theta in enumerate(theta): + logger.debug("Starting log likelihood evaluation for thetas %s / %s: %s", i + 1, len(theta), this_theta) - # Save settings - logger.debug("Saving settings to %s_settings.json", filename) + log_p_hat, t_hat = evaluate_flow_model( + model=self.model, thetas=[this_theta], xs=x, evaluate_score=evaluate_score + ) - settings = { - "method": self.method, - "method_type": self.method_type, - "n_observables": self.n_observables, - "n_parameters": self.n_parameters, - "n_hidden": list(self.n_hidden), - "activation": self.activation, - "features": self.features, - "nde_type": self.nde_type, - "maf_n_mades": self.maf_n_mades, - "maf_batch_norm": self.maf_batch_norm, - "maf_batch_norm_alpha": self.maf_batch_norm_alpha, - "maf_mog_n_components": self.maf_mog_n_components, - } + all_log_p_hat.append(log_p_hat) + all_t_hat.append(t_hat) - with open(filename + "_settings.json", "w") as f: - json.dump(settings, f) + all_log_p_hat = np.array(all_log_p_hat) + all_t_hat = np.array(all_t_hat) - # Save scaling - if self.x_scaling_stds is not None and self.x_scaling_means is not None: - logger.debug("Saving input scaling information to %s_x_means.npy and %s_x_stds.npy", filename, filename) - np.save(filename + "_x_means.npy", self.x_scaling_means) - np.save(filename + "_x_stds.npy", self.x_scaling_stds) + else: + logger.debug("Starting log likelihood evaluation") - # Save state dict - logger.debug("Saving state dictionary to %s_state_dict.pt", filename) - torch.save(self.model.state_dict(), filename + "_state_dict.pt") + all_log_p_hat, all_t_hat = evaluate_flow_model( + model=self.model, thetas=theta, xs=x, evaluate_score=evaluate_score + ) - # Save model - if save_model: - logger.debug("Saving model to %s_model.pt", filename) - torch.save(self.model, filename + "_model.pt") + logger.debug("Evaluation done") + return all_log_p_hat, all_t_hat - def load(self, filename): + def evaluate_log_likelihood_ratio(self, x, theta0, theta1, test_all_combinations, evaluate_score=False): """ - Loads a trained model from files. + Evaluates the log likelihood ratio as a function of the observation x, the numerator parameter point theta0, + and the denominator parameter point theta1. Parameters ---------- - filename : str - Path to the files. '_settings.json' and '_state_dict.pl' will be added. + x : ndarray or str + Sample of observations, or path to numpy file with observations. + + theta0 : ndarray or str + Numerator parameters, or path to numpy file. + + theta1 : ndarray or str + Denominator parameters, or path to numpy file. + + test_all_combinations : bool, optional + If method is not 'sally' and not 'sallino': If False, the number of samples in the observable and theta + files has to match, and the likelihood ratio is evaluated only for the combinations + `r(x_i | theta0_i, theta1_i)`. If True, `r(x_i | theta0_j, theta1_j)` for all pairwise combinations `i, j` + are evaluated. Default value: True. + + evaluate_score : bool, optional + If method is not 'sally' and not 'sallino', this sets whether in addition to the likelihood ratio the score + is evaluated. Default value: False. Returns ------- - None - """ + log_likelihood : ndarray + The estimated log likelihood. If test_all_combinations is True, the result has shape `(n_thetas, n_x)`. + Otherwise, it has shape `(n_samples,)`. - # Load settings - logger.debug("Loading settings from %s_settings.json", filename) + score : ndarray or None + None if + evaluate_score is False. Otherwise the derived estimated score at `theta`. If test_all_combinations is + True, the result has shape `(n_thetas, n_x, n_parameters)`. Otherwise, it has shape + `(n_samples, n_parameters)`. - with open(filename + "_settings.json", "r") as f: - settings = json.load(f) + """ - method = settings["method"] - n_observables = int(settings["n_observables"]) - n_parameters = int(settings["n_parameters"]) - n_hidden = tuple([int(item) for item in settings["n_hidden"]]) - activation = str(settings["activation"]) - features = settings["features"] - nde_type = settings["nde_type"] - maf_n_mades = int(settings["maf_n_mades"]) - maf_batch_norm = bool(settings["maf_batch_norm"]) - maf_batch_norm_alpha = float(settings["maf_batch_norm_alpha"]) - maf_mog_n_components = int(settings["maf_mog_n_components"]) - - logger.debug( - " Found method %s, %s observables, %s parameters, %s hidden layers, %s activation function, " - "features %s", - method, - n_observables, - n_parameters, - n_hidden, - activation, - features, - ) + if self.model is None: + raise ValueError("No model -- train or load model before evaluating it!") - # Features - if features == "None": - self.features = None - if features is not None: - self.features = list([int(item) for item in features]) + # Load training data + logger.debug("Loading evaluation data") + x = load_and_check(x) + theta0 = load_and_check(theta0) + theta1 = load_and_check(theta1) - # Load scaling - try: - self.x_scaling_means = np.load(filename + "_x_means.npy") - self.x_scaling_stds = np.load(filename + "_x_stds.npy") - logger.debug( - " Found input scaling information: means %s, stds %s", self.x_scaling_means, self.x_scaling_stds - ) - except FileNotFoundError: - logger.warning("Scaling information not found in %s", filename) - self.x_scaling_means = None - self.x_scaling_stds = None + # Scale observables + x = self._transform_inputs(x) - # Create model and save in self - self._create_model( - method, - n_observables, - n_parameters, - n_hidden, - activation, - nde_type, - maf_n_mades, - maf_batch_norm, - maf_batch_norm_alpha, - maf_mog_n_components, - ) + # Restrict features + if self.features is not None: + x = x[:, self.features] - # Load state dict - logger.debug("Loading state dictionary from %s_state_dict.pt", filename) - self.model.load_state_dict(torch.load(filename + "_state_dict.pt")) + # Balance thetas + if len(theta1) > len(theta0): + theta0 = [theta0[i % len(theta0)] for i in range(len(theta1))] + elif len(theta1) < len(theta0): + theta1 = [theta1[i % len(theta1)] for i in range(len(theta0))] - def _initialize_input_transform(self, x, transform=True): - if transform: - self.x_scaling_means = np.mean(x, axis=0) - self.x_scaling_stds = np.maximum(np.std(x, axis=0), 1.0e-6) - else: - n_parameters = x.shape[0] + log_p_hat0, t_hat0 = self.evaluate_log_likelihood( + x, theta0, test_all_combinations=test_all_combinations, evaluate_score=evaluate_score + ) + log_p_hat1, t_hat1 = self.evaluate_log_likelihood( + x, theta1, test_all_combinations=test_all_combinations, evaluate_score=evaluate_score + ) + log_r_hat = log_p_hat0 - log_p_hat1 - self.x_scaling_means = np.zeros(n_parameters) - self.x_scaling_stds = np.ones(n_parameters) + return log_r_hat, t_hat0, t_hat1 - def _transform_inputs(self, x): - if self.x_scaling_means is not None and self.x_scaling_stds is not None: - x_scaled = x - self.x_scaling_means - x_scaled /= self.x_scaling_stds - else: - x_scaled = x - return x_scaled + def evaluate_score(self, *args, **kwargs): + raise NotImplementedError("Please use evaluate_log_likelihood(evaluate_score=True).") - def _create_model( - self, - method, - n_observables, - n_parameters, - n_hidden, - activation, - nde_type=None, - maf_n_mades=None, - maf_batch_norm=None, - maf_batch_norm_alpha=None, - maf_mog_n_components=None, - ): + def calculate_fisher_information(self, *args, **kwargs): + raise NotImplementedError( + "Please use evaluate_log_likelihood_ratio(evaluate_score=True) and calculate the " + "Fisher information manually." + ) - self.method = method - self.n_observables = n_observables - self.n_parameters = n_parameters - self.n_hidden = n_hidden - self.activation = activation - self.maf_n_mades = maf_n_mades - self.maf_batch_norm = maf_batch_norm - self.maf_batch_norm_alpha = maf_batch_norm_alpha - self.maf_mog_n_components = maf_mog_n_components - - self.method_type = get_method_type(method) - if self.method_type == "parameterized": - self.model = ParameterizedRatioEstimator( - n_observables=n_observables, n_parameters=n_parameters, n_hidden=n_hidden, activation=activation + def evaluate(self, *args, **kwargs): + return self.evaluate_log_likelihood(*args, **kwargs) + + def _create_model(self): + if self.n_components > 1: + self.model = ConditionalMixtureMaskedAutoregressiveFlow( + n_conditionals=self.n_parameters, + n_inputs=self.n_observables, + n_components=self.n_components, + n_hiddens=self.n_hidden, + n_mades=self.n_mades, + activation=self.activation, + batch_norm=self.batch_norm is not None, + alpha=self.batch_norm, ) - elif self.method_type == "doubly_parameterized": - self.model = DoublyParameterizedRatioEstimator( - n_observables=n_observables, n_parameters=n_parameters, n_hidden=n_hidden, activation=activation - ) - elif self.method_type == "local_score": - self.model = LocalScoreEstimator( - n_observables=n_observables, n_parameters=n_parameters, n_hidden=n_hidden, activation=activation - ) - elif self.method_type == "nde": - self.nde_type = nde_type - if nde_type == "maf": - self.model = ConditionalMaskedAutoregressiveFlow( - n_conditionals=n_parameters, - n_inputs=n_observables, - n_hiddens=n_hidden, - n_mades=maf_n_mades, - activation=activation, - batch_norm=maf_batch_norm, - alpha=maf_batch_norm_alpha, - ) - elif nde_type == "mafmog": - self.model = ConditionalMixtureMaskedAutoregressiveFlow( - n_conditionals=n_parameters, - n_inputs=n_observables, - n_components=maf_mog_n_components, - n_hiddens=n_hidden, - n_mades=maf_n_mades, - activation=activation, - batch_norm=maf_batch_norm, - alpha=maf_batch_norm_alpha, - ) - else: - raise RuntimeError("Unknown NDE type {}".format(nde_type)) else: - raise RuntimeError("Unknown method {}".format(method)) - + self.model = ConditionalMaskedAutoregressiveFlow( + n_conditionals=self.n_parameters, + n_inputs=self.n_observables, + n_hiddens=self.n_hidden, + n_mades=self.n_mades, + activation=self.activation, + batch_norm=self.batch_norm is not None, + alpha=self.batch_norm, + ) -class EnsembleForge: + @staticmethod + def _check_required_data(method, t_xz): + if method == ["scandal"] and t_xz is None: + raise RuntimeError("Method {} requires joint score information".format(method)) + + @staticmethod + def _package_training_data(method, x, theta, t_xz): + data = OrderedDict() + data["x"] = x + data["theta"] = theta + if method in ["scandal"]: + data["t_xz"] = t_xz + return data + + def _wrap_settings(self): + settings = super(LikelihoodEstimator, self)._wrap_settings() + settings["estimator_type"] = "likelihood" + settings["n_components"] = self.n_components + settings["batch_norm"] = self.batch_norm + settings["n_mades"] = self.n_mades + return settings + + def _unwrap_settings(self, settings): + super(LikelihoodEstimator, self)._unwrap_settings(settings) + + estimator_type = str(settings["estimator_type"]) + if estimator_type != "likelihood": + raise RuntimeError("Saved model is an incompatible estimator type {}.".format(estimator_type)) + + self.n_components = int(settings["n_components"]) + self.n_mades = int(settings["n_mades"]) + self.batch_norm = settings["batch_norm"] + if self.batch_norm == "None": + self.batch_norm = None + if self.batch_norm is not None: + self.batch_norm = float(self.batch_norm) + + +class Ensemble: """ - Ensemble methods for likelihood ratio and score information. + Ensemble methods for likelihood, likelihood ratio, and score estimation. - Generally, EnsembleForge instances can be used very similarly to MLForge instances: + Generally, Ensemble instances can be used very similarly to Estimator instances: - * The initialization of EnsembleForge takes a list of (trained or untrained) MLForge instances. - * The methods `EnsembleForge.train_one()` and `EnsembleForge.train_all()` train the estimators (this can also be - done outside of EnsembleForge). - * `EnsembleForge.calculate_expectation()` can be used to calculate the expectation of the estimation likelihood + * The initialization of Ensemble takes a list of (trained or untrained) Estimator instances. + * The methods `Ensemble.train_one()` and `Ensemble.train_all()` train the estimators (this can also be + done outside of Ensemble). + * `Ensemble.calculate_expectation()` can be used to calculate the expectation of the estimation likelihood ratio or the expected estimated score over a validation sample. Ideally (and assuming the correct sampling), these expectation values should be close to zero. Deviations from zero therefore point out that the estimator is probably inaccurate. - * `EnsembleForge.evaluate()` and `EnsembleForge.calculate_fisher_information()` can then be used to calculate - ensemble predictions. The user has the option to treat all estimators equally ('committee method') or to give those - with expected score / ratio close to zero a higher weight. - * `EnsembleForge.save()` and `EnsembleForge.load()` can store all estimators in one folder. + * `Ensemble.evaluate_log_likelihood()`, `Ensemble.evaluate_log_likelihood_ratio()`, `Ensemble.evaluate_score()`, + and `Ensemble.calculate_fisher_information()` can then be used to calculate + ensemble predictions. + * `Ensemble.save()` and `Ensemble.load()` can store all estimators in one folder. The individual estimators in the ensemble can be trained with different methods, but they have to be of the same - type: either all estimators are single-parameterized likelihood ratio estimators, or all estimators are - doubly-parameterized likelihood estimators, or all estimators are local score regressors. + type: either all estimators are ParameterizedRatioEstimator instances, or all estimators are + DoubleParameterizedRatioEstimator instances, or all estimators are ScoreEstimator instances, or all estimators are + LikelihoodEstimator instances.. Parameters ---------- - estimators : None or int or list of (MLForge or str), optional + estimators : None or list of Estimator, optional If int, sets the number of estimators that will be created as new MLForge instances. If list, sets the estimators directly, either from MLForge instances or filenames (that are then loaded with `MLForge.load()`). If None, the ensemble is initialized without estimators. Note that the estimators have @@ -1077,39 +1977,27 @@ class EnsembleForge: Attributes ---------- - estimators : list of MLForge + estimators : list of Estimator The estimators in the form of MLForge instances. """ def __init__(self, estimators=None): self.n_parameters = None self.n_observables = None + self.estimator_type = None # Initialize estimators if estimators is None: self.estimators = [] - elif isinstance(estimators, int): - self.estimators = [MLForge() for _ in range(estimators)] else: self.estimators = [] for estimator in estimators: - if isinstance(estimator, six.string_types): - estimator_object = MLForge() - estimator_object.load(estimator) - elif isinstance(estimator, MLForge): - estimator_object = estimator + if isinstance(estimator, Estimator): + self.estimators.append(estimator) else: - raise ValueError("Entry {} in estimators is neither str nor MLForge instance") - - self.estimators.append(estimator_object) + raise ValueError("Entry {} in estimators is neither str nor Estimator instance") self.n_estimators = len(self.estimators) - self.expectations = None - - # Consistency checks - for estimator in self.estimators: - assert isinstance(estimator, MLForge), "Estimator is no MLForge instance!" - self._check_consistency() def add_estimator(self, estimator): @@ -1118,28 +2006,24 @@ def add_estimator(self, estimator): Parameters ---------- - estimator : MLForge or str - The estimator, either as MLForge instance or filename (which is then loaded with `MLForge.load()`). + estimator : Estimator + The estimator. Returns ------- None """ - if isinstance(estimator, six.string_types): - estimator_object = MLForge() - estimator_object.load(estimator) - elif isinstance(estimator, MLForge): - estimator_object = estimator - else: - raise ValueError("Entry {} in estimators is neither str nor MLForge instance") + if not isinstance(estimator, Estimator): + raise ValueError("Entry {} in estimators is neither str nor Estimator instance") - self.estimators.append(estimator_object) + self.estimators.append(estimator) self.n_estimators = len(self.estimators) + self._check_consistency() def train_one(self, i, **kwargs): """ - Trains an individual estimator. See `MLForge.train()`. + Trains an individual estimator. See `Estimator.train()`. Parameters ---------- @@ -1147,7 +2031,7 @@ def train_one(self, i, **kwargs): The index `0 <= i < n_estimators` of the estimator to be trained. kwargs : dict - Parameters for `MLForge.train()`. + Parameters for `Estimator.train()`. Returns ------- @@ -1155,18 +2039,16 @@ def train_one(self, i, **kwargs): """ - self._check_consistency(kwargs) - self.estimators[i].train(**kwargs) def train_all(self, **kwargs): """ - Trains all estimators. See `MLForge.train()`. + Trains all estimators. See `Estimator.train()`. Parameters ---------- kwargs : dict - Parameters for `MLForge.train()`. If a value in this dict is a list, it has to have length `n_estimators` + Parameters for `Estimator.train()`. If a value in this dict is a list, it has to have length `n_estimators` and contain one value of this parameter for each of the estimators. Otherwise the value is used as parameter for the training of all the estimators. @@ -1183,8 +2065,6 @@ def train_all(self, **kwargs): assert len(kwargs[key]) == self.n_estimators, "Keyword {} has wrong length {}".format(key, len(value)) - self._check_consistency(kwargs) - for i, estimator in enumerate(self.estimators): kwargs_this_estimator = {} for key, value in six.iteritems(kwargs): @@ -1193,212 +2073,180 @@ def train_all(self, **kwargs): logger.info("Training estimator %s / %s in ensemble", i + 1, self.n_estimators) estimator.train(**kwargs_this_estimator) - def calculate_expectation(self, x_filename, theta0_filename=None, theta1_filename=None): + def evaluate_log_likelihood(self, estimator_weights=None, calculate_covariance=False, **kwargs): """ - Calculates the expectation of the estimation likelihood ratio or the expected estimated score over a validation - sample. Ideally (and assuming the correct sampling), these expectation values should be close to zero. - Deviations from zero therefore point out that the estimator is probably inaccurate. + Estimates the log likelihood from each estimator and returns the ensemble mean (and, if calculate_covariance is + True, the covariance between them). Parameters ---------- - x_filename : str - Path to an unweighted sample of observations, as saved by the `madminer.sampling.SampleAugmenter` functions. + estimator_weights : ndarray or None, optional + Weights for each estimator in the ensemble. If None, all estimators have an equal vote. Default value: None. - theta0_filename : str or None, optional - Path to an unweighted sample of numerator parameters, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required if the estimators were trained with the 'alice', 'alice2', 'alices', 'alices2', 'carl', - 'carl2', 'nde', 'rascal', 'rascal2', 'rolr', 'rolr2', or 'scandal' method. Default value: None. + calculate_covariance : bool, optional + If True, the covariance between the different estimators is calculated. Default value: False. - theta1_filename : str or None, optional - Path to an unweighted sample of denominator parameters, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required if the estimators were trained with the 'alice2', 'alices2', 'carl2', 'rascal2', or - 'rolr2' method. Default value: None. + kwargs + Arguments for the evaluation. See the documentation of the relevant Estimator class. Returns ------- - expectations : ndarray - Expected score (if the estimators were trained with the 'sally' or 'sallino' methods) or likelihood ratio - (otherwise). + log_likelihood : ndarray + Mean prediction for the log likelihood. + + covariance : ndarray or None + If calculate_covariance is True, the covariance matrix between the estimators. Otherwise None. """ - logger.info("Calculating expectation for %s estimators in ensemble", self.n_estimators) + logger.info("Evaluating %s estimators in ensemble", self.n_estimators) - self.expectations = [] - method_type = self._check_consistency() + # Calculate weights of each estimator in vote + if estimator_weights is None: + estimator_weights = np.ones(self.n_estimators) + assert len(estimator_weights) == self.n_estimators + estimator_weights /= np.sum(estimator_weights) + logger.debug("Estimator weights: %s", estimator_weights) + # Calculate estimator predictions + predictions = [] for i, estimator in enumerate(self.estimators): logger.info("Starting evaluation for estimator %s / %s in ensemble", i + 1, self.n_estimators) + predictions.append(estimator.evaluate_log_likelihood(**kwargs)[0]) + predictions = np.array(predictions) - # Calculate expected score / ratio - if method_type == "local_score": - prediction = estimator.evaluate(x_filename, theta0_filename, theta1_filename) - else: - raise NotImplementedError("Expectation calculation currently only implemented for SALLY and SALLINO!") + # Calculate weighted means and covariance matrices + mean = np.average(predictions, axis=0, weights=estimator_weights) - self.expectations.append(np.mean(prediction, axis=0)) + if calculate_covariance: + predictions_flat = predictions.reshape((predictions.shape[0], -1)) + covariance = np.cov(predictions_flat.T, aweights=estimator_weights) + covariance = covariance.reshape(list(predictions.shape) + list(predictions.shape)) + else: + covariance = None - self.expectations = np.array(self.expectations) + return mean, covariance - return self.expectations + def evaluate_log_likelihood_ratio(self, estimator_weights=None, calculate_covariance=False, **kwargs): + """ + Estimates the log likelihood ratio from each estimator and returns the ensemble mean (and, if + calculate_covariance is True, the covariance between them). - def evaluate( - self, - x, - theta0_filename=None, - theta1_filename=None, - test_all_combinations=True, - vote_expectation_weight=None, - calculate_covariance=False, - return_individual_predictions=False, - ): + Parameters + ---------- + estimator_weights : ndarray or None, optional + Weights for each estimator in the ensemble. If None, all estimators have an equal vote. Default value: None. + + calculate_covariance : bool, optional + If True, the covariance between the different estimators is calculated. Default value: False. + + kwargs + Arguments for the evaluation. See the documentation of the relevant Estimator class. + + Returns + ------- + log_likelihood_ratio : ndarray + Mean prediction for the log likelihood ratio. + + covariance : ndarray or None + If calculate_covariance is True, the covariance matrix between the estimators. Otherwise None. """ - Evaluates the estimators of the likelihood ratio (or, if method is 'sally' or 'sallino', the score), and - calculates the ensemble mean or variance. - The user has the option to treat all estimators equally ('committee method') or to give those with expected - score / ratio close to zero (as calculated by `calculate_expectation()`) a higher weight. In the latter case, - the ensemble mean `f(x)` is calculated as `f(x) = sum_i w_i f_i(x)` with weights - `w_i = exp(-vote_expectation_weight |E[f_i]|) / sum_j exp(-vote_expectation_weight |E[f_j]|)`. Here `f_i(x)` - are the individual estimators and `E[f_i]` is the expectation value calculated by `calculate_expectation()`. + logger.info("Evaluating %s estimators in ensemble", self.n_estimators) - Parameters - ---------- - x : str or ndarray - Sample of observations, or path to numpy file with observations, as saved by the - `madminer.sampling.SampleAugmenter` functions. Note that this sample has to be sampled from the reference - parameter where the score is estimated with the SALLY / SALLINO estimator! + # Calculate weights of each estimator in vote + if estimator_weights is None: + estimator_weights = np.ones(self.n_estimators) + assert len(estimator_weights) == self.n_estimators + estimator_weights /= np.sum(estimator_weights) + logger.debug("Estimator weights: %s", estimator_weights) - theta0_filename : str or None, optional - Path to an unweighted sample of numerator parameters, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required if the estimator was trained with the 'alice', 'alice2', 'alices', 'alices2', 'carl', - 'carl2', 'nde', 'rascal', 'rascal2', 'rolr', 'rolr2', or 'scandal' method. Default value: None. + # Calculate estimator predictions + predictions = [] + for i, estimator in enumerate(self.estimators): + logger.info("Starting evaluation for estimator %s / %s in ensemble", i + 1, self.n_estimators) + predictions.append(estimator.evaluate_log_likelihood_ratio(**kwargs)[0]) + predictions = np.array(predictions) - theta1_filename : str or None, optional - Path to an unweighted sample of denominator parameters, as saved by the `madminer.sampling.SampleAugmenter` - functions. Required if the estimator was trained with the 'alice2', 'alices2', 'carl2', 'rascal2', or - 'rolr2' method. Default value: None. + # Calculate weighted means and covariance matrices + mean = np.average(predictions, axis=0, weights=estimator_weights) - test_all_combinations : bool, optional - If method is not 'sally' and not 'sallino': If False, the number of samples in the observable and theta - files has to match, and the likelihood ratio is evaluated only for the combinations - `r(x_i | theta0_i, theta1_i)`. If True, `r(x_i | theta0_j, theta1_j)` for all pairwise combinations `i, j` - are evaluated. Default value: True. + if calculate_covariance: + predictions_flat = predictions.reshape((predictions.shape[0], -1)) + covariance = np.cov(predictions_flat.T, aweights=estimator_weights) + covariance = covariance.reshape(list(predictions.shape) + list(predictions.shape)) + else: + covariance = None - vote_expectation_weight : float or list of float or None, optional - Factor that determines how much more weight is given to those estimators with small expectation value (as - calculated by `calculate_expectation()`). If a list is given, results are returned for each element in the - list. If None, or if `calculate_expectation()` has not been called, all estimators are treated equal. - Default value: None. + return mean, covariance + + def evaluate_score(self, estimator_weights=None, calculate_covariance=False, **kwargs): + """ + Estimates the score from each estimator and returns the ensemble mean (and, if + calculate_covariance is True, the covariance between them). + + Parameters + ---------- + estimator_weights : ndarray or None, optional + Weights for each estimator in the ensemble. If None, all estimators have an equal vote. Default value: None. calculate_covariance : bool, optional - Whether the covariance matrix is calculated. Default value: False. + If True, the covariance between the different estimators is calculated. Default value: False. - return_individual_predictions : bool, optional - Whether the individual estimator predictions are returned. Default value: False. + kwargs + Arguments for the evaluation. See the documentation of the relevant Estimator class. Returns ------- - mean_prediction : ndarray or list of ndarray - The (weighted) ensemble mean of the estimators. If the estimators were trained with `method='sally'` or - `method='sallino'`, this is an array of the estimator for `t(x_i | theta_ref)` for all events `i`. - Otherwise, the estimated likelihood ratio (if test_all_combinations is True, the result has shape - `(n_thetas, n_x)`, otherwise, it has shape `(n_samples,)`). If more then one value vote_expectation_weight - is given, this is a list with results for all entries in vote_expectation_weight. - - covariance : None or ndarray or list of ndarray - The covariance matrix of the (flattened) predictions, defined as the ensemble covariance. If more then one - value vote_expectation_weight is given, this is a list with results - for all entries in vote_expectation_weight. If calculate_covariance is False, None is returned. - - weights : ndarray or list of ndarray - Only returned if return_individual_predictions is True. The estimator weights `w_i`. If more then one value - vote_expectation_weight is given, this is a list with results for all entries in vote_expectation_weight. + log_likelihood_ratio : ndarray + Mean prediction for the log likelihood ratio. - individual_predictions : ndarray - Only returned if return_individual_predictions is True. The individual estimator predictions. + covariance : ndarray or None + If calculate_covariance is True, the covariance matrix between the estimators. Otherwise None. """ + logger.info("Evaluating %s estimators in ensemble", self.n_estimators) # Calculate weights of each estimator in vote - if self.expectations is None or vote_expectation_weight is None: - weights = [np.ones(self.n_estimators)] - else: - if len(self.expectations.shape) == 1: - expectations_norm = self.expectations - elif len(self.expectations.shape) == 2: - expectations_norm = np.linalg.norm(self.expectations, axis=1) - else: - expectations_norm = [np.linalg.norm(expectation) for expectation in self.expectations] - - if not isinstance(vote_expectation_weight, list): - vote_expectation_weight = [vote_expectation_weight] - - weights = [] - for vote_weight in vote_expectation_weight: - if vote_weight is None: - these_weights = np.ones(self.n_estimators) - else: - these_weights = np.exp(-vote_weight * expectations_norm) - these_weights /= np.sum(these_weights) - weights.append(these_weights) - - logger.debug("Estimator weights: %s", weights) + if estimator_weights is None: + estimator_weights = np.ones(self.n_estimators) + assert len(estimator_weights) == self.n_estimators + estimator_weights /= np.sum(estimator_weights) + logger.debug("Estimator weights: %s", estimator_weights) # Calculate estimator predictions predictions = [] for i, estimator in enumerate(self.estimators): logger.info("Starting evaluation for estimator %s / %s in ensemble", i + 1, self.n_estimators) - - predictions.append( - estimator.evaluate(x, theta0_filename, theta1_filename, test_all_combinations, evaluate_score=False) - ) - - logger.debug("Estimator %s predicts %s for first event", i + 1, predictions[-1][0, :]) + predictions.append(estimator.evaluate_score(**kwargs)) predictions = np.array(predictions) # Calculate weighted means and covariance matrices - means = [] - covariances = [] - - for these_weights in weights: - mean = np.average(predictions, axis=0, weights=these_weights) - means.append(mean) - - if calculate_covariance: - predictions_flat = predictions.reshape((predictions.shape[0], -1)) - - covariance = np.cov(predictions_flat.T, aweights=these_weights) - else: - covariance = None - - covariances.append(covariance) + mean = np.average(predictions, axis=0, weights=estimator_weights) - # Returns - if len(weights) == 1: - if return_individual_predictions: - return means[0], covariances[0], weights[0], predictions - return means[0], covariances[0] + if calculate_covariance: + predictions_flat = predictions.reshape((predictions.shape[0], -1)) + covariance = np.cov(predictions_flat.T, aweights=estimator_weights) + covariance = covariance.reshape(list(predictions.shape) + list(predictions.shape)) + else: + covariance = None - if return_individual_predictions: - return means, covariances, weights, predictions - return means, covariances + return mean, covariance def calculate_fisher_information( self, x, obs_weights=None, + estimator_weights=None, n_events=1, mode="score", - uncertainty="ensemble", - vote_expectation_weight=None, - return_individual_predictions=False, + calculate_covariance=True, sum_events=True, ): """ - Calculates expected Fisher information matrices for an ensemble of SALLY estimators. + Calculates expected Fisher information matrices for an ensemble of ScoreEstimator instances. There are two ways of calculating the ensemble average. In the default "score" mode, the ensemble average for the score is calculated for each event, and the Fisher information is calculated based on these mean scores. In @@ -1433,6 +2281,9 @@ def calculate_fisher_information( obs_weights : None or ndarray, optional Weights for the observations. If None, all events are taken to have equal weight. Default value: None. + estimator_weights : ndarray or None, optional + Weights for each estimator in the ensemble. If None, all estimators have an equal vote. Default value: None. + n_events : float, optional Expected number of events for which the kinematic Fisher information should be calculated. Default value: 1. @@ -1441,22 +2292,8 @@ def calculate_fisher_information( are the sample mean and covariance calculated. If mode is "score", the sample mean is calculated for the score for each event. Default value: "score". - uncertainty : {"ensemble", "expectation", "sum", "none"}, optional - How the covariance matrix of the Fisher information estimate is calculate. With "ensemble", the ensemble - covariance is used (only supported if mode is "information"). With "expectation", the expectation of the - score is used as a measure of the uncertainty of the score estimator, and this uncertainty is propagated - through to the covariance matrix. With "sum", both terms are summed (only supported if mode is - "information"). With "none", no uncertainties are calculated. Default value: "ensemble". - - vote_expectation_weight : float or list of float or None, optional - If mode is "information", this factor determines how much more weight is given to those estimators with - small expectation value (as calculated by `calculate_expectation()`). If a list is given, results are - returned for each element in the list. If None, or if `calculate_expectation()` has not been called, all - estimators are treated equal. Default value: None. - - return_individual_predictions : bool, optional - If mode is "information", sets whether the individual estimator predictions are returned. Default value: - False. + calculate_covariance : bool, optional + If True, the covariance between the different estimators is calculated. Default value: True. sum_events : bool, optional If True or mode is "information", the expected Fisher information summed over the events x is calculated. @@ -1465,86 +2302,53 @@ def calculate_fisher_information( Returns ------- - mean_prediction : ndarray or list of ndarray + mean_prediction : ndarray Expected kinematic Fisher information matrix with shape `(n_events, n_parameters, n_parameters)` if sum_events is False and mode is "score", or `(n_parameters, n_parameters)` in any other case. - covariance : ndarray or list of ndarray - The covariance matrix of the Fisher information estimate. Its definition depends on the value of - uncertainty; by default, the covariance is defined as the ensemble covariance (only supported if mode is - "information"). This object has four indices, `cov_(ij)(i'j')`, ordered as i j i' j'. It has shape - `(n_parameters, n_parameters, n_parameters, n_parameters)`. If more then one value vote_expectation_weight - is given, this is a list with results for all entries in vote_expectation_weight. - - weights : ndarray or list of ndarray - Only returned if return_individual_predictions is True. The estimator weights `w_i`. If more then one value - vote_expectation_weight is given, this is a list with results for all entries in vote_expectation_weight. - - individual_predictions : ndarray - Only returned if return_individual_predictions is True. The individual estimator predictions. - + covariance : ndarray or None + The covariance of the estimated Fisher information matrix. This object has four indices, `cov_(ij)(i'j')`, + ordered as i j i' j'. It has shape `(n_parameters, n_parameters, n_parameters, n_parameters)`. """ logger.debug("Evaluating Fisher information for %s estimators in ensemble", self.n_estimators) + # Check ensemble + if self.estimator_type != "score": + raise NotImplementedError( + "Fisher information calculation is only implemented for local score estimators " + "(ScoreEstimator instances)." + ) + # Check input if mode not in ["score", "information"]: raise ValueError("Unknown mode {}, has to be 'score' or 'information'!".format(mode)) - if mode == "score": - vote_expectation_weight = None - - if uncertainty == "expectation" or uncertainty == "sum": - if self.expectations is None: - raise RuntimeError( - "Expectations have not been calculated, cannot use uncertainty mode 'expectation' " "or 'sum'!" - ) - # Calculate estimator_weights of each estimator in vote - if self.expectations is None or vote_expectation_weight is None: - estimator_weights = [np.ones(self.n_estimators)] - else: - if len(self.expectations.shape) == 1: - expectations_norm = self.expectations - elif len(self.expectations.shape) == 2: - expectations_norm = np.linalg.norm(self.expectations, axis=1) - else: - expectations_norm = [np.linalg.norm(expectation) for expectation in self.expectations] - - if not isinstance(vote_expectation_weight, list): - vote_expectation_weight = [vote_expectation_weight] - - estimator_weights = [] - for vote_weight in vote_expectation_weight: - if vote_weight is None: - these_weights = np.ones(self.n_estimators) - else: - these_weights = np.exp(-vote_weight * expectations_norm) - these_weights /= np.sum(these_weights) - estimator_weights.append(these_weights) - - logger.debug(" Estimator estimator_weights: %s", estimator_weights) + if estimator_weights is None: + estimator_weights = np.ones(self.n_estimators) + assert len(estimator_weights) == self.n_estimators + estimator_weights /= np.sum(estimator_weights) + logger.debug("Estimator weights: %s", estimator_weights) - predictions = [] + covariance = None # "information" mode if mode == "information": # Calculate estimator predictions + predictions = [] for i, estimator in enumerate(self.estimators): logger.debug("Starting evaluation for estimator %s / %s in ensemble", i + 1, self.n_estimators) predictions.append(estimator.calculate_fisher_information(x=x, weights=obs_weights, n_events=n_events)) predictions = np.array(predictions) - # Calculate weighted means and covariance matrices - means = [] - ensemble_covariances = [] + # Calculate weighted mean and covariance + information = np.average(predictions, axis=0, weights=estimator_weights) - for these_weights in estimator_weights: - mean = np.average(predictions, axis=0, weights=these_weights) - means.append(mean) + predictions_flat = predictions.reshape((predictions.shape[0], -1)) - predictions_flat = predictions.reshape((predictions.shape[0], -1)) - covariance = np.cov(predictions_flat.T, aweights=these_weights) + if calculate_covariance: + covariance = np.cov(predictions_flat.T, aweights=estimator_weights) covariance_shape = ( predictions.shape[1], predictions.shape[2], @@ -1553,8 +2357,6 @@ def calculate_fisher_information( ) covariance = covariance.reshape(covariance_shape) - ensemble_covariances.append(covariance) - # "score" mode: else: # Load training data @@ -1586,71 +2388,39 @@ def calculate_fisher_information( # Fisher information prediction (based on mean scores) if sum_events: - information_mean = float(n_events) * np.sum( + information = float(n_events) * np.sum( obs_weights[:, np.newaxis, np.newaxis] * score_mean[:, :, np.newaxis] * score_mean[:, np.newaxis, :], axis=0, ) else: - information_mean = ( + information = ( float(n_events) * obs_weights[:, np.newaxis, np.newaxis] * score_mean[:, :, np.newaxis] * score_mean[:, np.newaxis, :] ) - means = [information_mean] - - # Fisher information predictions based on shifted scores - informations_shifted = float(n_events) * np.sum( - obs_weights[np.newaxis, :, np.newaxis, np.newaxis] - * score_shifted_predictions[:, :, :, np.newaxis] - * score_shifted_predictions[:, :, np.newaxis, :], - axis=1, - ) # (n_estimators, n_parameters, n_parameters) - - n_params = score_mean.shape[1] - informations_shifted = informations_shifted.reshape(-1, n_params ** 2) - information_cov = np.cov(informations_shifted.T) - information_cov = information_cov.reshape(n_params, n_params, n_params, n_params) - ensemble_covariances = [information_cov] + + if calculate_covariance: + # Fisher information predictions based on shifted scores + informations_shifted = float(n_events) * np.sum( + obs_weights[np.newaxis, :, np.newaxis, np.newaxis] + * score_shifted_predictions[:, :, :, np.newaxis] + * score_shifted_predictions[:, :, np.newaxis, :], + axis=1, + ) # (n_estimators, n_parameters, n_parameters) + + n_params = score_mean.shape[1] + informations_shifted = informations_shifted.reshape(-1, n_params ** 2) + covariance = np.cov(informations_shifted.T) + covariance = covariance.reshape(n_params, n_params, n_params, n_params) # Let's check the expected score expected_score = [np.einsum("n,ni->i", obs_weights, score_mean)] logger.debug("Expected per-event score (should be close to zero):\n%s", expected_score) - # Calculate uncertainty through non-zero score expectation - expectation_covariances = None - if uncertainty == "expectation" or uncertainty == "sum": - expectation_covariances = [] - for these_weights, expectation in zip(estimator_weights, self.expectations): - mean_expectation = np.average(expectation, weights=these_weights, axis=0) - expectation_covariances.append( - n_events - * np.einsum("a,b,c,d->abcd", mean_expectation, mean_expectation, mean_expectation, mean_expectation) - ) - - # Final covariances - if uncertainty == "ensemble": - covariances = ensemble_covariances - elif uncertainty == "expectation": - covariances = expectation_covariances - elif uncertainty == "sum": - covariances = [cov1 + cov2 for cov1, cov2 in zip(ensemble_covariances, expectation_covariances)] - elif uncertainty == "none": - covariances = [None for cov in ensemble_covariances] - else: - raise ValueError("Unknown uncertainty mode {}".format(uncertainty)) - - # Returns - if len(estimator_weights) == 1: - if return_individual_predictions and mode == "information": - return means[0], covariances[0], estimator_weights[0], predictions - return means[0], covariances[0] - - if return_individual_predictions and mode == "information": - return means, covariances, estimator_weights, predictions - return means, covariances + return information, covariance def save(self, folder, save_model=False): """ @@ -1663,7 +2433,7 @@ def save(self, folder, save_model=False): save_model : bool, optional If True, the whole model is saved in addition to the state dict. This is not necessary for loading it - again with EnsembleForge.load(), but can be useful for debugging, for instance to plot the computational + again with Ensemble.load(), but can be useful for debugging, for instance to plot the computational graph. Returns @@ -1677,13 +2447,7 @@ def save(self, folder, save_model=False): # Save ensemble settings logger.debug("Saving ensemble setup to %s/ensemble.json", folder) - - if self.expectations is None: - expectations = "None" - else: - expectations = self.expectations.tolist() - - settings = {"n_estimators": self.n_estimators, "expectations": expectations} + settings = {"estimator_type": self.estimator_type, "n_estimators": self.n_estimators} with open(folder + "/ensemble.json", "w") as f: json.dump(settings, f) @@ -1706,48 +2470,35 @@ def load(self, folder): None """ - # Load ensemble settings logger.debug("Loading ensemble setup from %s/ensemble.json", folder) - with open(folder + "/ensemble.json", "r") as f: settings = json.load(f) - self.n_estimators = settings["n_estimators"] - self.expectations = settings["expectations"] - if self.expectations == "None": - self.expectations = None - if self.expectations is not None: - self.expectations = np.array(self.expectations) - - logger.info("Found ensemble with %s estimators and expectations %s", self.n_estimators, self.expectations) + self.n_estimators = int(settings["n_estimators"]) + try: + estimator_type = str(settings["estimator_type"]) + except KeyError: + raise RuntimeError( + "Can't find estimator type information in file. Maybe this file was created with" + " an incompatible MadMiner version < v0.3.0?" + ) + logger.info("Found %s ensemble with %s estimators", estimator_type, self.n_estimators) # Load estimators self.estimators = [] for i in range(self.n_estimators): - estimator = MLForge() + estimator = self._get_estimator_class(estimator_type)() estimator.load(folder + "/estimator_" + str(i)) self.estimators.append(estimator) - - # Check consistency and update n_parameters, n_observables self._check_consistency() - def _check_consistency(self, keywords=None): + def _check_consistency(self): """ Internal function that checks if all estimators belong to the same category (local score regression, single-parameterized likelihood ratio estimator, doubly parameterized likelihood ratio estimator). - Parameters - ---------- - keywords : dict or None, optional - kwargs passed to `train_one()` or `train_all()`. - - Returns - ------- - method_type : {"local_score", "parameterized", "doubly_parameterized"} - Method type of this ensemble. - Raises ------ RuntimeError @@ -1755,40 +2506,22 @@ def _check_consistency(self, keywords=None): """ # Accumulate methods of all estimators - methods = [estimator.method for estimator in self.estimators] + all_types = [self._get_estimator_type(estimator) for estimator in self.estimators] all_n_parameters = [estimator.n_parameters for estimator in self.estimators] all_n_observables = [estimator.n_observables for estimator in self.estimators] - if keywords is not None: - keyword_method = keywords.get("method", None) - if isinstance(keyword_method, list): - methods += keyword_method - else: - methods.append(keyword_method) - # Check consistency of methods - self.method_type = None - - for method in methods: - if method in ["sally", "sallino"]: - this_method_type = "local_score" - elif method in ["carl", "rolr", "rascal", "alice", "alices", "nde", "scandal"]: - this_method_type = "parameterized" - elif method in ["carl2", "rolr2", "rascal2", "alice2", "alices2"]: - this_method_type = "doubly_parameterized" - elif method is None: - continue - else: - raise RuntimeError("Unknown method %s", method) + self.estimator_type = None - if self.method_type is None: - self.method_type = this_method_type + for estimator_type in all_types: + if self.estimator_type is None: + self.estimator_type = estimator_type - if self.method_type != this_method_type: + if self.estimator_type != estimator_type: raise RuntimeError( "Ensemble with inconsistent estimator methods! All methods have to be either" " single-parameterized ratio estimators, doubly parameterized ratio estimators," - " or local score estimators. Found methods " + ", ".join(methods) + "." + " or local score estimators. Found types " + ", ".join(all_types) + "." ) # Check consistency of parameter and observable numnbers @@ -1810,5 +2543,35 @@ def _check_consistency(self, keywords=None): "Ensemble with inconsistent numbers of parameters for different estimators: %s", all_n_observables ) - # Return method type of ensemble - return self.method_type + @staticmethod + def _get_estimator_type(estimator): + if not isinstance(estimator, Estimator): + raise RuntimeError("Estimator is not an Estimator instance!") + + if isinstance(estimator, ParameterizedRatioEstimator): + return "parameterized_ratio" + elif isinstance(estimator, DoubleParameterizedRatioEstimator): + return "double_parameterized_ratio" + elif isinstance(estimator, ScoreEstimator): + return "score" + elif isinstance(estimator, LikelihoodEstimator): + return "likelihood" + else: + raise RuntimeError("Estimator is an unknown Estimator type!") + + @staticmethod + def _get_estimator_class(estimator_type): + if estimator_type == "parameterized_ratio": + return ParameterizedRatioEstimator + elif estimator_type == "double_parameterized_ratio": + return DoubleParameterizedRatioEstimator + elif estimator_type == "score": + return ScoreEstimator + elif estimator_type == "likelihood": + return LikelihoodEstimator + else: + raise RuntimeError("Unknown estimator type {}!".format(estimator_type)) + + +class TheresAGoodReasonThisDoesntWork(Exception): + pass diff --git a/madminer/plotting.py b/madminer/plotting.py index 584c16989..1b53c0377 100644 --- a/madminer/plotting.py +++ b/madminer/plotting.py @@ -1,6 +1,5 @@ from __future__ import absolute_import, division, print_function, unicode_literals -import six import numpy as np from matplotlib import pyplot as plt import matplotlib @@ -8,9 +7,8 @@ import logging from madminer.sampling import SampleAugmenter -from madminer.utils.analysis import mdot, get_theta_benchmark_matrix -from madminer.morphing import NuisanceMorpher -from madminer.utils.various import weighted_quantile, sanitize_array, shuffle +from madminer.utils.morphing import NuisanceMorpher +from madminer.utils.various import weighted_quantile, sanitize_array, shuffle, mdot logger = logging.getLogger(__name__) @@ -93,11 +91,11 @@ def plot_uncertainty( obs_idx = list(sa.observables.keys()).index(observable) # Get event data (observations and weights) - x, weights_benchmarks = sa.extract_raw_data() + x, weights_benchmarks = sa.weighted_events() x = x[:, obs_idx] # Theta matrix - theta_matrix = get_theta_benchmark_matrix("morphing", theta, sa.benchmarks, sa.morpher) + theta_matrix = sa._get_theta_benchmark_matrix(theta) weights = mdot(theta_matrix, weights_benchmarks) # Remove negative weights @@ -412,7 +410,7 @@ def plot_distributions( observable_labels = [all_observables[obs] for obs in observable_indices] # Get event data (observations and weights) - x, weights_benchmarks = sa.extract_raw_data() + x, weights_benchmarks = sa.weighted_events() logger.debug("Loaded raw data with shapes %s, %s", x.shape, weights_benchmarks.shape) # Remove negative weights @@ -443,14 +441,7 @@ def plot_distributions( if draw_nuisance_toys is not None: n_nuisance_toys_drawn = draw_nuisance_toys - theta_matrices = [] - for theta in parameter_points: - if isinstance(theta, six.string_types): - matrix = get_theta_benchmark_matrix("benchmark", theta, sa.benchmarks) - else: - matrix = get_theta_benchmark_matrix("morphing", theta, sa.benchmarks, sa.morpher) - theta_matrices.append(matrix) - + theta_matrices = [sa._get_theta_benchmark_matrix(theta) for theta in parameter_points] logger.debug("Calculated %s theta matrices", len(theta_matrices)) # Nuisance parameters @@ -611,8 +602,8 @@ def plot_2d_morphing_basis( Parameters ---------- - morpher : Morpher - Morpher instance with defined basis. + morpher : PhysicsMorpher + PhysicsMorpher instance with defined basis. xlabel : str, optional Label for the x axis. Default value: r'$\theta_0$'. @@ -682,8 +673,8 @@ def plot_nd_morphing_basis_scatter(morpher, crange=(1.0, 100.0), n_test_thetas=1 Parameters ---------- - morpher : Morpher - Morpher instance with defined basis. + morpher : PhysicsMorpher + PhysicsMorpher instance with defined basis. crange : tuple of float, optional Range `(min, max)` for the color map. Default value: (1. 100.). @@ -741,8 +732,8 @@ def plot_nd_morphing_basis_slices(morpher, crange=(1.0, 100.0), resolution=50): Parameters ---------- - morpher : Morpher - Morpher instance with defined basis. + morpher : PhysicsMorpher + PhysicsMorpher instance with defined basis. crange : tuple of float, optional Range `(min, max)` for the color map. @@ -1091,7 +1082,6 @@ def plot_fisherinfo_barplot( if eigenvalue_colors is None: eigenvalue_colors = ["C{}".format(str(i)) for i in range(10)] - operator_order = [i for i in range(0, size_upper)] eigenvalue_linewidth = 1.5 # Upper plot @@ -1134,7 +1124,7 @@ def plot_fisherinfo_barplot( ax1.set_ylim(0.0001 * y_max, 2.0 * y_max) ax1.set_xticks(xpos_ticks) - ax1.set_xticklabels(["" for l in labels], rotation=40, ha="right") + ax1.set_xticklabels(["" for _ in labels], rotation=40, ha="right") ax1.set_ylabel(r"$I_{ij}$ eigenvalues") # Lower plot diff --git a/madminer/sampling.py b/madminer/sampling.py index 60dd8761f..96ade3ba9 100644 --- a/madminer/sampling.py +++ b/madminer/sampling.py @@ -1,215 +1,25 @@ from __future__ import absolute_import, division, print_function, unicode_literals +import time import logging import numpy as np -import collections -import six +import multiprocessing +from functools import partial -from madminer.utils.interfaces.madminer_hdf5 import load_madminer_settings, madminer_event_loader +from madminer.analysis import DataAnalyzer +from madminer.utils.interfaces.madminer_hdf5 import madminer_event_loader from madminer.utils.interfaces.madminer_hdf5 import save_preformatted_events_to_madminer_file -from madminer.utils.analysis import get_theta_value, get_theta_benchmark_matrix, get_dtheta_benchmark_matrix -from madminer.utils.analysis import calculate_augmented_data, parse_theta, mdot -from madminer.morphing import Morpher, NuisanceMorpher -from madminer.utils.various import format_benchmark, create_missing_folders, shuffle, balance_thetas +from madminer.utils.various import create_missing_folders, shuffle logger = logging.getLogger(__name__) -def combine_and_shuffle( - input_filenames, output_filename, k_factors=None, overwrite_existing_file=True, shuffle_sample=True -): +class SampleAugmenter(DataAnalyzer): """ - Combines multiple MadMiner files into one, and shuffles the order of the events. - - Note that this function assumes that all samples are generated with the same setup, including identical benchmarks - (and thus morphing setup). If it is used with samples with different settings, there will be wrong results! - There are no explicit cross checks in place yet! - - Parameters - ---------- - input_filenames : list of str - List of paths to the input MadMiner files. - - output_filename : str - Path to the combined MadMiner file. - - k_factors : float or list of float, optional - Multiplies the weights in input_filenames with a universal factor (if k_factors is a float) or with independent - factors (if it is a list of float). Default value: None. - - overwrite_existing_file : bool, optional - If True and if the output file exists, it is overwritten. Default value: True. - - shuffle_sample : bool, optional - If True, the output shuffle will be shuffled. Default value: True. - - Returns - ------- - None - - """ - - logger.debug("Combining and shuffling samples") - - if len(input_filenames) > 1: - logger.warning( - "Careful: this tool assumes that all samples are generated with the same setup, including" - " identical benchmarks (and thus morphing setup). If it is used with samples with different" - " settings, there will be wrong results! There are no explicit cross checks in place yet." - ) - - # k factors - if k_factors is None: - k_factors = [1.0 for _ in input_filenames] - elif isinstance(k_factors, float): - k_factors = [k_factors for _ in input_filenames] - - # Copy first file to output_filename - logger.info("Copying setup from %s to %s", input_filenames[0], output_filename) - - # TODO: More memory efficient strategy - - # Load events - all_observations = None - all_weights = None - - for i, (filename, k_factor) in enumerate(zip(input_filenames, k_factors)): - logger.info( - "Loading samples from file %s / %s at %s, multiplying weights with k factor %s", - i + 1, - len(input_filenames), - filename, - k_factor, - ) - - for observations, weights in madminer_event_loader(filename): - if all_observations is None: - all_observations = observations - all_weights = k_factor * weights - else: - all_observations = np.vstack((all_observations, observations)) - all_weights = np.vstack((all_weights, k_factor * weights)) - - # Shuffle - if shuffle_sample: - all_observations, all_weights = shuffle(all_observations, all_weights) - - # Save result - save_preformatted_events_to_madminer_file( - filename=output_filename, - observations=all_observations, - weights=all_weights, - copy_setup_from=input_filenames[0], - overwrite_existing_samples=overwrite_existing_file, - ) - - -def constant_benchmark_theta(benchmark_name): - """ - Utility function to be used as input to various SampleAugmenter functions, specifying a single parameter benchmark. - - Parameters - ---------- - benchmark_name : str - Name of the benchmark (as in `madminer.core.MadMiner.add_benchmark`) - - - Returns - ------- - output : tuple - Input to various SampleAugmenter functions - - """ - return "benchmark", benchmark_name - - -def multiple_benchmark_thetas(benchmark_names): - """ - Utility function to be used as input to various SampleAugmenter functions, specifying multiple parameter benchmarks. - - Parameters - ---------- - benchmark_names : list of str - List of names of the benchmarks (as in `madminer.core.MadMiner.add_benchmark`) - - - Returns - ------- - output : tuple - Input to various SampleAugmenter functions - - """ - return "benchmarks", benchmark_names - - -def constant_morphing_theta(theta): - """ - Utility function to be used as input to various SampleAugmenter functions, specifying a single parameter point theta - in a morphing setup. - - Parameters - ---------- - theta : ndarray or list - Parameter point with shape `(n_parameters,)` - - Returns - ------- - output : tuple - Input to various SampleAugmenter functions - - """ - return "theta", np.asarray(theta) - - -def multiple_morphing_thetas(thetas): - """ - Utility function to be used as input to various SampleAugmenter functions, specifying multiple parameter points - theta in a morphing setup. - - Parameters - ---------- - thetas : ndarray or list of lists or list of ndarrays - Parameter points with shape `(n_thetas, n_parameters)` - - Returns - ------- - output : tuple - Input to various SampleAugmenter functions - - """ - return "thetas", [np.asarray(theta) for theta in thetas] - - -def random_morphing_thetas(n_thetas, priors): - """ - Utility function to be used as input to various SampleAugmenter functions, specifying random parameter points - sampled from a prior in a morphing setup. - - Parameters - ---------- - n_thetas : int - Number of parameter points to be sampled - - priors : list of tuples - Priors for each parameter is characterized by a tuple of the form `(prior_shape, prior_param_0, prior_param_1)`. - Currently, the supported prior_shapes are `flat`, in which case the two other parameters are the lower and upper - bound of the flat prior, and `gaussian`, in which case they are the mean and standard deviation of a Gaussian. - - Returns - ------- - output : tuple - Input to various SampleAugmenter functions - - """ - return "random", (n_thetas, priors) - - -class SampleAugmenter: - """ - Sampling and data augmentation. + Sampling / unweighting and data augmentation. After the generated events have been analyzed and the observables and weights have been saved into a MadMiner file, - for instance with `madminer.delphes.DelphesProcessor` or `madminer.lhe.LHEProcessor`, the next step is typically + for instance with `madminer.delphes.DelphesReader` or `madminer.lhe.LHEReader`, the next step is typically the generation of training and evaluation data for the machine learning algorithms. This generally involves two (related) tasks: unweighting, i.e. the creation of samples that do not carry individual weights but follow some distribution, and the extraction of the joint likelihood ratio and / or joint score (the "augmented data"). @@ -217,18 +27,18 @@ class SampleAugmenter: After inializing `SampleAugmenter` with the filename of a MadMiner file, this is done with a single function call. Depending on the downstream inference algorithm, there are different possibilities: - * `SampleAugmenter.extract_samples_train_plain()` creates plain training samples without augmented data. - * `SampleAugmenter.extract_samples_train_local()` creates training samples for local methods based on the score, + * `SampleAugmenter.sample_train_plain()` creates plain training samples without augmented data. + * `SampleAugmenter.sample_train_local()` creates training samples for local methods based on the score, such as SALLY and SALLINO. - * `SampleAugmenter.extract_samples_train_global()` creates training samples for non-local methods based on density + * `SampleAugmenter.sample_train_density()` creates training samples for non-local methods based on density estimation and the score, such as SCANDAL. - * `SampleAugmenter.extract_samples_train_ratio()` creates training samples for non-local, ratio-based methods + * `SampleAugmenter.sample_train_ratio()` creates training samples for non-local, ratio-based methods like RASCAL or ALICE. - * `SampleAugmenter.extract_samples_train_more_ratios()` does the same, but can extract joint ratios and scores + * `SampleAugmenter.sample_train_more_ratios()` does the same, but can extract joint ratios and scores at more parameter points. This additional information can be used efficiently in the setup with a "doubly parameterized" likelihood ratio estimator that models the dependence on both the numerator and denominator hypothesis. - * `SampleAugmenter.extract_samples_test()` creates evaluation samples for all methods. + * `SampleAugmenter.sample_test()` creates evaluation samples for all methods. Please see the tutorial for a walkthrough. @@ -262,88 +72,18 @@ class SampleAugmenter: """ def __init__(self, filename, disable_morphing=False, include_nuisance_parameters=True): - # Save setup - self.include_nuisance_parameters = include_nuisance_parameters - self.madminer_filename = filename - - logger.info("Loading data from %s", filename) - - # Load data - ( - self.parameters, - self.benchmarks, - self.benchmark_is_nuisance, - self.morphing_components, - self.morphing_matrix, - self.observables, - self.n_samples, - _, - self.reference_benchmark, - self.nuisance_parameters, - ) = load_madminer_settings(filename, include_nuisance_benchmarks=include_nuisance_parameters) - - self.n_parameters = len(self.parameters) - self.n_benchmarks = len(self.benchmarks) - self.n_benchmarks_phys = np.sum(np.logical_not(self.benchmark_is_nuisance)) - - self.n_nuisance_parameters = 0 - if self.nuisance_parameters is not None and include_nuisance_parameters: - self.n_nuisance_parameters = len(self.nuisance_parameters) - else: - self.nuisance_parameters = None - - logger.info("Found %s parameters", self.n_parameters) - for key, values in six.iteritems(self.parameters): - logger.debug( - " %s (LHA: %s %s, maximal power in squared ME: %s, range: %s)", - key, - values[0], - values[1], - values[2], - values[3], - ) - - if self.nuisance_parameters is not None: - logger.info("Found %s nuisance parameters", self.n_nuisance_parameters) - for key, values in six.iteritems(self.nuisance_parameters): - logger.debug(" %s (%s)", key, values) - else: - logger.info("Did not find nuisance parameters") - - logger.info("Found %s benchmarks, of which %s physical", self.n_benchmarks, self.n_benchmarks_phys) - for (key, values), is_nuisance in zip(six.iteritems(self.benchmarks), self.benchmark_is_nuisance): - if is_nuisance: - logger.debug(" %s: nuisance parameter", key) - else: - logger.debug(" %s: %s", key, format_benchmark(values)) - - logger.info("Found %s observables", len(self.observables)) - for i, obs in enumerate(self.observables): - logger.debug(" %2.2s %s", i, obs) - logger.info("Found %s events", self.n_samples) - - # Morphing - self.morpher = None - if self.morphing_matrix is not None and self.morphing_components is not None and not disable_morphing: - self.morpher = Morpher(self.parameters) - self.morpher.set_components(self.morphing_components) - self.morpher.set_basis(self.benchmarks, morphing_matrix=self.morphing_matrix) - - logger.info("Found morphing setup with %s components", len(self.morphing_components)) - - else: - logger.info("Did not find morphing setup.") + super(SampleAugmenter, self).__init__(filename, disable_morphing, include_nuisance_parameters) - # Nuisance morphing - self.nuisance_morpher = None - if self.nuisance_parameters is not None: - self.nuisance_morpher = NuisanceMorpher( - self.nuisance_parameters, list(self.benchmarks.keys()), self.reference_benchmark - ) - logger.info("Found nuisance morphing setup") - - def extract_samples_train_plain( - self, theta, n_samples, folder, filename, test_split=0.5, switch_train_test_events=False + def sample_train_plain( + self, + theta, + n_samples, + nu=None, + folder=None, + filename=None, + test_split=0.2, + switch_train_test_events=False, + n_processes=1, ): """ Extracts plain training samples `x ~ p(x|theta)` without any augmented data. This can be use for standard @@ -360,21 +100,32 @@ def extract_samples_train_plain( n_samples : int Total number of events to be drawn. - folder : str - Path to the folder where the resulting samples should be saved (ndarrays in .npy format). + nu : None or tuple, optional + Tuple (type, value) that defines the nuisance parameter point or prior over parameter points for the + sampling. Default value: None - filename : str + folder : str or None + Path to the folder where the resulting samples should be saved (ndarrays in .npy format). Default value: + None. + + filename : str or None Filenames for the resulting samples. A prefix such as 'x' or 'theta0' as well as the extension - '.npy' will be added automatically. + '.npy' will be added automatically. Default value: + None. test_split : float or None, optional Fraction of events reserved for the evaluation sample (that will not be used for any training samples). - Default value: 0.5. + Default value: 0.2. switch_train_test_events : bool, optional If True, this function generates a training sample from the events normally reserved for test samples. Default value: False. + n_processes : None or int, optional + If None or larger than 1, MadMiner will use multiprocessing to parallelize the sampling. In this case, + n_workers sets the number of jobs running in parallel, and None will use the number of CPUs. Default value: + 1. + Returns ------- x : ndarray @@ -385,25 +136,28 @@ def extract_samples_train_plain( Parameter points used for sampling with shape `(n_samples, n_parameters)`. The same information is saved as a file in the given folder. + effective_n_samples : int + Effective number of samples, defined as 1/max(event_probabilities), where event_probabilities are the + fractions of the cross section carried by each event. + """ logger.info("Extracting plain training sample. Sampling according to %s", theta) create_missing_folders([folder]) - # Thetas - theta_types, theta_values, n_samples_per_theta = parse_theta(theta, n_samples) - - # Train / test split - start_event, end_event = self._train_test_split(not switch_train_test_events, test_split) + # Parameters + parsed_thetas, n_samples_per_theta = self._parse_theta(theta, n_samples) + parsed_nus = self._parse_nu(nu, len(parsed_thetas)) + sets = self._build_sets([parsed_thetas], [parsed_nus]) # Start - x, _, (theta,) = self._extract_sample( - theta_sets_types=[theta_types], - theta_sets_values=[theta_values], - n_samples_per_theta=n_samples_per_theta, - start_event=start_event, - end_event=end_event, + x, _, (theta,), effective_n_samples = self._sample( + sets=sets, + n_samples_per_set=n_samples_per_theta, + use_train_events=not switch_train_test_events, + test_split=test_split, + n_processes=n_processes, ) # Save data @@ -411,17 +165,19 @@ def extract_samples_train_plain( np.save(folder + "/theta_" + filename + ".npy", theta) np.save(folder + "/x_" + filename + ".npy", x) - return x, theta + return x, theta, min(effective_n_samples) - def extract_samples_train_local( + def sample_train_local( self, theta, n_samples, - folder, - filename, - nuisance_score=False, - test_split=0.5, + nu=None, + folder=None, + filename=None, + nuisance_score="auto", + test_split=0.2, switch_train_test_events=False, + n_processes=1, log_message=True, ): """ @@ -437,26 +193,37 @@ def extract_samples_train_local( n_samples : int Total number of events to be drawn. - folder : str - Path to the folder where the resulting samples should be saved (ndarrays in .npy format). + nu : None or tuple, optional + Tuple (type, value) that defines the nuisance parameter point or prior over parameter points for the + sampling. Default value: None - filename : str + folder : str or None + Path to the folder where the resulting samples should be saved (ndarrays in .npy format). Default value: + None. + + filename : str or None Filenames for the resulting samples. A prefix such as 'x' or 'theta0' as well as the extension - '.npy' will be added automatically. + '.npy' will be added automatically. Default value: + None. - nuisance_score : bool, optional - If True and if the sample contains nuisance parameters, the score with respect to the nuisance parameters - (at the default position) will also be calculated. Otherwise, only the score with respect to the - physics parameters is calculated. Default: False. + nuisance_score : bool or "auto", optional + If True, the score with respect to the nuisance parameters (at the default position) will also be + calculated. If False, only the score with respect to the physics parameters is calculated. For "auto", + the nuisance score will be calculated if a nuisance setup is defined. Default: True. test_split : float or None, optional Fraction of events reserved for the evaluation sample (that will not be used for any training samples). - Default value: 0.5. + Default value: 0.2. switch_train_test_events : bool, optional If True, this function generates a training sample from the events normally reserved for test samples. Default value: False. + n_processes : None or int, optional + If None or larger than 1, MadMiner will use multiprocessing to parallelize the sampling. In this case, + n_workers sets the number of jobs running in parallel, and None will use the number of CPUs. Default value: + 1. + log_message : bool, optional If True, logging output. This option is only designed for internal use. @@ -475,6 +242,10 @@ def extract_samples_train_local( nuisance_score is True) or `(n_samples, n_parameters)`. The same information is saved as a file in the given folder. + effective_n_samples : int + Effective number of samples, defined as 1/max(event_probabilities), where event_probabilities are the + fractions of the cross section carried by each event. + """ if log_message: @@ -486,47 +257,32 @@ def extract_samples_train_local( create_missing_folders([folder]) # Check setup + if nuisance_score == "auto": + nuisance_score = self.nuisance_morpher is not None if self.morpher is None: raise RuntimeError("No morphing setup loaded. Cannot calculate score.") - if self.nuisance_morpher is None and nuisance_score: raise RuntimeError("No nuisance parameters defined. Cannot calculate nuisance score.") - # Thetas - theta_types, theta_values, n_samples_per_theta = parse_theta(theta, n_samples) + # Parameters + parsed_thetas, n_samples_per_theta = self._parse_theta(theta, n_samples) + parsed_nus = self._parse_nu(nu, len(parsed_thetas)) + sets = self._build_sets([parsed_thetas], [parsed_nus]) # Augmented data (gold) augmented_data_definitions = [("score", 0)] - if nuisance_score: - augmented_data_definitions += [("nuisance_score",)] - - # Train / test split - start_event, end_event = self._train_test_split(not switch_train_test_events, test_split) # Start - x, augmented_data, (theta,) = self._extract_sample( - theta_sets_types=[theta_types], - theta_sets_values=[theta_values], - n_samples_per_theta=n_samples_per_theta, + x, augmented_data, (theta,), effective_n_samples = self._sample( + sets=sets, + n_samples_per_set=n_samples_per_theta, augmented_data_definitions=augmented_data_definitions, nuisance_score=nuisance_score, - start_event=start_event, - end_event=end_event, + use_train_events=not switch_train_test_events, + test_split=test_split, + n_processes=n_processes, ) - - t_xz_physics = augmented_data[0] - if nuisance_score: - t_xz_nuisance = augmented_data[1] - t_xz = np.hstack([t_xz_physics, t_xz_nuisance]) - - logger.debug( - "Found physical score with shape %s, nuisance score with shape %s, combined shape %s", - t_xz_physics.shape, - t_xz_nuisance.shape, - t_xz.shape, - ) - else: - t_xz = t_xz_physics + t_xz = augmented_data[0] # Save data if filename is not None and folder is not None: @@ -534,10 +290,19 @@ def extract_samples_train_local( np.save(folder + "/x_" + filename + ".npy", x) np.save(folder + "/t_xz_" + filename + ".npy", t_xz) - return x, theta, t_xz + return x, theta, t_xz, min(effective_n_samples) - def extract_samples_train_global( - self, theta, n_samples, folder, filename, test_split=0.5, switch_train_test_events=False + def sample_train_density( + self, + theta, + n_samples, + nu=None, + folder=None, + filename=None, + nuisance_score="auto", + test_split=0.2, + switch_train_test_events=False, + n_processes=1, ): """ Extracts training samples x ~ p(x|theta) as well as the joint score t(x, z|theta), where theta is sampled @@ -553,21 +318,36 @@ def extract_samples_train_global( n_samples : int Total number of events to be drawn. - folder : str - Path to the folder where the resulting samples should be saved (ndarrays in .npy format). + nu : None or tuple, optional + Tuple (type, value) that defines the nuisance parameter point or prior over parameter points for the + sampling. Default value: None - filename : str + folder : str or None + Path to the folder where the resulting samples should be saved (ndarrays in .npy format). Default value: + None. + + filename : str or None Filenames for the resulting samples. A prefix such as 'x' or 'theta0' as well as the extension - '.npy' will be added automatically. + '.npy' will be added automatically. Default value: None. + + nuisance_score : bool or "auto", optional + If True, the score with respect to the nuisance parameters (at the default position) will also be + calculated. If False, only the score with respect to the physics parameters is calculated. For "auto", + the nuisance score will be calculated if a nuisance setup is defined. Default: True. test_split : float or None, optional Fraction of events reserved for the evaluation sample (that will not be used for any training samples). - Default value: 0.5. + Default value: 0.2. switch_train_test_events : bool, optional If True, this function generates a training sample from the events normally reserved for test samples. Default value: False. + n_processes : None or int, optional + If None or larger than 1, MadMiner will use multiprocessing to parallelize the sampling. In this case, + n_workers sets the number of jobs running in parallel, and None will use the number of CPUs. Default value: + 1. + Returns ------- x : ndarray @@ -582,6 +362,10 @@ def extract_samples_train_global( Joint score evaluated at theta with shape `(n_samples, n_parameters)`. The same information is saved as a file in the given folder. + effective_n_samples : int + Effective number of samples, defined as 1/max(event_probabilities), where event_probabilities are the + fractions of the cross section carried by each event. + """ logger.info( @@ -590,18 +374,32 @@ def extract_samples_train_global( theta, ) - return self.extract_samples_train_local( - theta, - n_samples, - folder, - filename, + return self.sample_train_local( + theta=theta, + n_samples=n_samples, + nu=nu, + folder=folder, + filename=filename, + nuisance_score=nuisance_score, test_split=test_split, switch_train_test_events=switch_train_test_events, + n_processes=n_processes, log_message=False, ) - def extract_samples_train_ratio( - self, theta0, theta1, n_samples, folder, filename, test_split=0.5, switch_train_test_events=False + def sample_train_ratio( + self, + theta0, + theta1, + n_samples, + nu0=None, + nu1=None, + folder=None, + filename=None, + nuisance_score="auto", + test_split=0.2, + switch_train_test_events=False, + n_processes=1, ): """ Extracts training samples `x ~ p(x|theta0)` and `x ~ p(x|theta1)` together with the class label `y`, the joint @@ -623,21 +421,41 @@ def extract_samples_train_ratio( n_samples : int Total number of events to be drawn. - folder : str - Path to the folder where the resulting samples should be saved (ndarrays in .npy format). + nu0 : None or tuple, optional + Tuple (type, value) that defines the numerator nuisance parameter point or prior over parameter points for + the sampling. Default value: None - filename : str + nu1 : None or tuple, optional + Tuple (type, value) that defines the denominator nuisance parameter point or prior over parameter points for + the sampling. Default value: None + + folder : str or None + Path to the folder where the resulting samples should be saved (ndarrays in .npy format). Default value: + None. + + filename : str or None Filenames for the resulting samples. A prefix such as 'x' or 'theta0' as well as the extension - '.npy' will be added automatically. + '.npy' will be added automatically. Default value: + None. + + nuisance_score : bool or "auto", optional + If True, the score with respect to the nuisance parameters (at the default position) will also be + calculated. If False, only the score with respect to the physics parameters is calculated. For "auto", + the nuisance score will be calculated if a nuisance setup is defined. Default: True. test_split : float or None, optional Fraction of events reserved for the evaluation sample (that will not be used for any training samples). - Default value: 0.5. + Default value: 0.2. switch_train_test_events : bool, optional If True, this function generates a training sample from the events normally reserved for test samples. Default value: False. + n_processes : None or int, optional + If None or larger than 1, MadMiner will use multiprocessing to parallelize the sampling. In this case, + n_workers sets the number of jobs running in parallel, and None will use the number of CPUs. Default value: + 1. + Returns ------- x : ndarray @@ -665,6 +483,10 @@ def extract_samples_train_ratio( information is saved as a file in the given folder. If morphing is not set up, None is returned (and no file is saved). + effective_n_samples : int + Effective number of samples, defined as 1/max(event_probabilities), where event_probabilities are the + fractions of the cross section carried by each event. + """ logger.info( @@ -674,76 +496,87 @@ def extract_samples_train_ratio( theta1, ) + create_missing_folders([folder]) + + # Check setup + if nuisance_score == "auto": + nuisance_score = self.nuisance_morpher is not None if self.morpher is None: logging.warning("No morphing setup loaded. Cannot calculate joint score.") - - create_missing_folders([folder]) + if self.nuisance_morpher is None and nuisance_score: + raise RuntimeError("No nuisance parameters defined. Cannot calculate nuisance score.") # Augmented data (gold) augmented_data_definitions = [("ratio", 0, 1)] if self.morpher is not None: augmented_data_definitions.append(("score", 0)) - # Train / test split - start_event, end_event = self._train_test_split(not switch_train_test_events, test_split) - # Thetas for theta0 sampling - theta0_types, theta0_values, n_samples_per_theta0 = parse_theta(theta0, n_samples // 2) - theta1_types, theta1_values, n_samples_per_theta1 = parse_theta(theta1, n_samples // 2) + parsed_theta0s, n_samples_per_theta0 = self._parse_theta(theta0, n_samples // 2) + parsed_theta1s, n_samples_per_theta1 = self._parse_theta(theta1, n_samples // 2) + parsed_nu0s = self._parse_nu(nu0, len(parsed_theta0s)) + parsed_nu1s = self._parse_nu(nu1, len(parsed_theta1s)) + sets = self._build_sets([parsed_theta0s, parsed_theta1s], [parsed_nu0s, parsed_nu1s]) n_samples_per_theta = min(n_samples_per_theta0, n_samples_per_theta1) # Start for theta0 - if self.morpher is None: - x0, (r_xz0,), (theta0_0, theta1_0) = self._extract_sample( - theta_sets_types=[theta0_types, theta1_types], - theta_sets_values=[theta0_values, theta1_values], - sampling_theta_index=0, - n_samples_per_theta=n_samples_per_theta, + x0, (r_xz0,), (theta0_0, theta1_0), n_effective_samples_0 = self._sample( + sets=sets, + sampling_index=0, + n_samples_per_set=n_samples_per_theta, augmented_data_definitions=augmented_data_definitions, - start_event=start_event, - end_event=end_event, + nuisance_score=nuisance_score, + use_train_events=not switch_train_test_events, + test_split=test_split, + n_processes=n_processes, ) t_xz0 = None else: - x0, (r_xz0, t_xz0), (theta0_0, theta1_0) = self._extract_sample( - theta_sets_types=[theta0_types, theta1_types], - theta_sets_values=[theta0_values, theta1_values], - sampling_theta_index=0, - n_samples_per_theta=n_samples_per_theta, + x0, (r_xz0, t_xz0), (theta0_0, theta1_0), n_effective_samples_0 = self._sample( + sets=sets, + sampling_index=0, + n_samples_per_set=n_samples_per_theta, augmented_data_definitions=augmented_data_definitions, - start_event=start_event, - end_event=end_event, + nuisance_score=nuisance_score, + use_train_events=not switch_train_test_events, + test_split=test_split, + n_processes=n_processes, ) # Thetas for theta1 sampling (could be different if num or denom are random) - theta0_types, theta0_values, n_samples_per_theta0 = parse_theta(theta0, n_samples // 2) - theta1_types, theta1_values, n_samples_per_theta1 = parse_theta(theta1, n_samples // 2) + parsed_theta0s, n_samples_per_theta0 = self._parse_theta(theta0, n_samples // 2) + parsed_theta1s, n_samples_per_theta1 = self._parse_theta(theta1, n_samples // 2) + parsed_nu0s = self._parse_nu(nu0, len(parsed_theta0s)) + parsed_nu1s = self._parse_nu(nu1, len(parsed_theta1s)) + sets = self._build_sets([parsed_theta0s, parsed_theta1s], [parsed_nu0s, parsed_nu1s]) n_samples_per_theta = min(n_samples_per_theta0, n_samples_per_theta1) # Start for theta1 if self.morpher is None: - x1, (r_xz1,), (theta0_1, theta1_1) = self._extract_sample( - theta_sets_types=[theta0_types, theta1_types], - theta_sets_values=[theta0_values, theta1_values], - sampling_theta_index=1, - n_samples_per_theta=n_samples_per_theta, + x1, (r_xz1,), (theta0_1, theta1_1), n_effective_samples_1 = self._sample( + sets=sets, + sampling_index=1, + n_samples_per_set=n_samples_per_theta, augmented_data_definitions=augmented_data_definitions, - start_event=start_event, - end_event=end_event, + nuisance_score=nuisance_score, + use_train_events=not switch_train_test_events, + test_split=test_split, + n_processes=n_processes, ) t_xz1 = None else: - x1, (r_xz1, t_xz1), (theta0_1, theta1_1) = self._extract_sample( - theta_sets_types=[theta0_types, theta1_types], - theta_sets_values=[theta0_values, theta1_values], - sampling_theta_index=1, - n_samples_per_theta=n_samples_per_theta, + x1, (r_xz1, t_xz1), (theta0_1, theta1_1), n_effective_samples_1 = self._sample( + sets=sets, + sampling_index=1, + n_samples_per_set=n_samples_per_theta, augmented_data_definitions=augmented_data_definitions, - start_event=start_event, - end_event=end_event, + nuisance_score=nuisance_score, + use_train_events=not switch_train_test_events, + test_split=test_split, + n_processes=n_processes, ) # Combine @@ -774,18 +607,22 @@ def extract_samples_train_ratio( if self.morpher is not None: np.save(folder + "/t_xz_" + filename + ".npy", t_xz) - return x, theta0, theta1, y, r_xz, t_xz + return x, theta0, theta1, y, r_xz, t_xz, min(min(n_effective_samples_0), min(n_effective_samples_1)) - def extract_samples_train_more_ratios( + def sample_train_more_ratios( self, theta0, theta1, n_samples, - folder, - filename, + nu0=None, + nu1=None, + folder=None, + filename=None, additional_thetas=None, - test_split=0.5, + nuisance_score="auto", + test_split=0.2, switch_train_test_events=False, + n_processes=1, ): """ Extracts training samples `x ~ p(x|theta0)` and `x ~ p(x|theta1)` together with the class label `y`, the joint @@ -812,12 +649,22 @@ def extract_samples_train_more_ratios( n_samples : int Total number of events to be drawn. - folder : str - Path to the folder where the resulting samples should be saved (ndarrays in .npy format). + nu0 : None or tuple, optional + Tuple (type, value) that defines the numerator nuisance parameter point or prior over parameter points for + the sampling. Default value: None + + nu1 : None or tuple, optional + Tuple (type, value) that defines the denominator nuisance parameter point or prior over parameter points for + the sampling. Default value: None + + folder : str or None + Path to the folder where the resulting samples should be saved (ndarrays in .npy format). Default value: + None. - filename : str + filename : str or None Filenames for the resulting samples. A prefix such as 'x' or 'theta0' as well as the extension - '.npy' will be added automatically. + '.npy' will be added automatically. Default value: + None. additional_thetas : list of tuple or None list of tuples `(type, value)` that defines additional theta points at which ratio and score are evaluated, @@ -827,14 +674,24 @@ def extract_samples_train_more_ratios( `constant_benchmark_theta()`, `multiple_benchmark_thetas()`, `constant_morphing_theta()`, `multiple_morphing_thetas()`, or `random_morphing_thetas()`. Default value: None. + nuisance_score : bool or "auto", optional + If True, the score with respect to the nuisance parameters (at the default position) will also be + calculated. If False, only the score with respect to the physics parameters is calculated. For "auto", + the nuisance score will be calculated if a nuisance setup is defined. Default: True. + test_split : float or None, optional Fraction of events reserved for the evaluation sample (that will not be used for any training samples). - Default value: 0.5. + Default value: 0.2. switch_train_test_events : bool, optional If True, this function generates a training sample from the events normally reserved for test samples. Default value: False. + n_processes : None or int, optional + If None or larger than 1, MadMiner will use multiprocessing to parallelize the sampling. In this case, + n_workers sets the number of jobs running in parallel, and None will use the number of CPUs. Default value: + 1. + Returns ------- x : ndarray @@ -861,6 +718,10 @@ def extract_samples_train_more_ratios( Joint score evaluated at theta0 with shape `(n_samples, n_parameters)`. The same information is saved as a file in the given folder. + effective_n_samples : int + Effective number of samples, defined as 1/max(event_probabilities), where event_probabilities are the + fractions of the cross section carried by each event. + """ logger.info( @@ -870,11 +731,15 @@ def extract_samples_train_more_ratios( theta1, ) - if self.morpher is None: - raise RuntimeError("No morphing setup loaded. Cannot calculate score.") - create_missing_folders([folder]) + # Check setup + if nuisance_score == "auto": + nuisance_score = self.nuisance_morpher is not None + if self.morpher is None: + raise RuntimeError("No morphing setup loaded. Cannot calculate score.") + if self.nuisance_morpher is None and nuisance_score: + raise RuntimeError("No nuisance parameters defined. Cannot calculate nuisance score.") if additional_thetas is None: additional_thetas = [] n_additional_thetas = len(additional_thetas) @@ -888,41 +753,42 @@ def extract_samples_train_more_ratios( augmented_data_definitions_1.append(("ratio", i + 2, 1)) augmented_data_definitions_1.append(("score", i + 2)) - # Train / test split - start_event, end_event = self._train_test_split(not switch_train_test_events, test_split) - # Parse thetas for theta0 sampling - theta_types = [] - theta_values = [] + parsed_thetas = [] + parsed_nus = [] n_samples_per_theta = 1000000 - theta0_types, theta0_values, this_n_samples = parse_theta(theta0, n_samples // 2) - theta_types.append(theta0_types) - theta_values.append(theta0_values) + parsed_theta0s, this_n_samples = self._parse_theta(theta0, n_samples // 2) + parsed_nu0s = self._parse_nu(nu0, len(parsed_theta0s)) + parsed_thetas.append(parsed_theta0s) + parsed_nus.append(parsed_nu0s) n_samples_per_theta = min(this_n_samples, n_samples_per_theta) - theta1_types, theta1_values, this_n_samples = parse_theta(theta1, n_samples // 2) - theta_types.append(theta1_types) - theta_values.append(theta1_values) + parsed_theta1s, this_n_samples = self._parse_theta(theta1, n_samples // 2) + parsed_nu1s = self._parse_nu(nu1, len(parsed_theta1s)) + parsed_thetas.append(parsed_theta1s) + parsed_nus.append(parsed_nu1s) n_samples_per_theta = min(this_n_samples, n_samples_per_theta) for additional_theta in additional_thetas: - additional_theta_types, additional_theta_values, this_n_samples = parse_theta( - additional_theta, n_samples // 2 - ) - theta_types.append(additional_theta_types) - theta_values.append(additional_theta_values) + additional_parsed_thetas, this_n_samples = self._parse_theta(additional_theta, n_samples // 2) + parsed_thetas.append(additional_parsed_thetas) + additional_parsed_nu = self._parse_nu(nu1, len(additional_parsed_thetas)) + parsed_nus.append(additional_parsed_nu) n_samples_per_theta = min(this_n_samples, n_samples_per_theta) + sets = self._build_sets(parsed_thetas, parsed_nus) + # Start for theta0 - x_0, augmented_data_0, thetas_0 = self._extract_sample( - theta_sets_types=theta_types, - theta_sets_values=theta_values, - n_samples_per_theta=n_samples_per_theta, + x_0, augmented_data_0, thetas_0, n_effective_samples_0 = self._sample( + sets=sets, + n_samples_per_set=n_samples_per_theta, augmented_data_definitions=augmented_data_definitions_0, - sampling_theta_index=0, - start_event=start_event, - end_event=end_event, + sampling_index=0, + nuisance_score=nuisance_score, + use_train_events=not switch_train_test_events, + test_split=test_split, + n_processes=n_processes, ) n_actual_samples = x_0.shape[0] @@ -950,37 +816,41 @@ def extract_samples_train_more_ratios( theta1_0 = np.vstack([theta1_0] + thetas_eval) # Parse thetas for theta1 sampling - theta_types = [] - theta_values = [] + parsed_thetas = [] + parsed_nus = [] n_samples_per_theta = 1000000 - theta0_types, theta0_values, this_n_samples = parse_theta(theta0, n_samples // 2) - theta_types.append(theta0_types) - theta_values.append(theta0_values) + parsed_thetas0, this_n_samples = self._parse_theta(theta0, n_samples // 2) + parsed_nu0s = self._parse_nu(nu0, len(parsed_theta0s)) + parsed_thetas.append(parsed_thetas0) + parsed_nus.append(parsed_nu0s) n_samples_per_theta = min(this_n_samples, n_samples_per_theta) - theta1_types, theta1_values, this_n_samples = parse_theta(theta1, n_samples // 2) - theta_types.append(theta1_types) - theta_values.append(theta1_values) + parsed_thetas1, this_n_samples = self._parse_theta(theta1, n_samples // 2) + parsed_nu1s = self._parse_nu(nu1, len(parsed_theta1s)) + parsed_thetas.append(parsed_thetas1) + parsed_nus.append(parsed_nu1s) n_samples_per_theta = min(this_n_samples, n_samples_per_theta) for additional_theta in additional_thetas: - additional_theta_types, additional_theta_values, this_n_samples = parse_theta( - additional_theta, n_samples // 2 - ) - theta_types.append(additional_theta_types) - theta_values.append(additional_theta_values) + additional_parsed_thetas, this_n_samples = self._parse_theta(additional_theta, n_samples // 2) + additional_parsed_nu = self._parse_nu(nu0, len(additional_parsed_thetas)) + parsed_thetas.append(additional_parsed_thetas) + parsed_nus.append(additional_parsed_nu) n_samples_per_theta = min(this_n_samples, n_samples_per_theta) + sets = self._build_sets(parsed_thetas, parsed_nus) + # Start for theta1 - x_1, augmented_data_1, thetas_1 = self._extract_sample( - theta_sets_types=theta_types, - theta_sets_values=theta_values, - n_samples_per_theta=n_samples_per_theta, + x_1, augmented_data_1, thetas_1, n_effective_samples_1 = self._sample( + sets=sets, + n_samples_per_set=n_samples_per_theta, augmented_data_definitions=augmented_data_definitions_1, - sampling_theta_index=1, - start_event=start_event, - end_event=end_event, + sampling_index=1, + nuisance_score=nuisance_score, + use_train_events=not switch_train_test_events, + test_split=test_split, + n_processes=n_processes, ) n_actual_samples += x_1.shape[0] @@ -1040,9 +910,19 @@ def extract_samples_train_more_ratios( np.save(folder + "/t_xz0_" + filename + ".npy", t_xz0) np.save(folder + "/t_xz1_" + filename + ".npy", t_xz1) - return x, theta0, theta1, y, r_xz, t_xz0, t_xz1 + return x, theta0, theta1, y, r_xz, t_xz0, t_xz1, min(min(n_effective_samples_0), min(n_effective_samples_1)) - def extract_samples_test(self, theta, n_samples, folder, filename, test_split=0.5, switch_train_test_events=False): + def sample_test( + self, + theta, + n_samples, + nu=None, + folder=None, + filename=None, + test_split=0.2, + switch_train_test_events=False, + n_processes=1, + ): """ Extracts evaluation samples `x ~ p(x|theta)` without any augmented data. @@ -1056,21 +936,32 @@ def extract_samples_test(self, theta, n_samples, folder, filename, test_split=0. n_samples : int Total number of events to be drawn. - folder : str - Path to the folder where the resulting samples should be saved (ndarrays in .npy format). + nu : None or tuple, optional + Tuple (type, value) that defines the nuisance parameter point or prior over parameter points for the + sampling. Default value: None - filename : str + folder : str or None + Path to the folder where the resulting samples should be saved (ndarrays in .npy format). Default value: + None. + + filename : str or None Filenames for the resulting samples. A prefix such as 'x' or 'theta0' as well as the extension - '.npy' will be added automatically. + '.npy' will be added automatically. Default value: + None. test_split : float or None, optional Fraction of events reserved for the evaluation sample (that will not be used for any training samples). - Default value: 0.5. + Default value: 0.2. switch_train_test_events : bool, optional If True, this function generates a test sample from the events normally reserved for training samples. Default value: False. + n_processes : None or int, optional + If None or larger than 1, MadMiner will use multiprocessing to parallelize the sampling. In this case, + n_workers sets the number of jobs running in parallel, and None will use the number of CPUs. Default value: + 1. + Returns ------- x : ndarray @@ -1081,6 +972,10 @@ def extract_samples_test(self, theta, n_samples, folder, filename, test_split=0. Parameter points used for sampling with shape `(n_samples, n_parameters)`. The same information is saved as a file in the given folder. + effective_n_samples : int + Effective number of samples, defined as 1/max(event_probabilities), where event_probabilities are the + fractions of the cross section carried by each event. + """ logger.info("Extracting evaluation sample. Sampling according to %s", theta) @@ -1088,18 +983,17 @@ def extract_samples_test(self, theta, n_samples, folder, filename, test_split=0. create_missing_folders([folder]) # Thetas - theta_types, theta_values, n_samples_per_theta = parse_theta(theta, n_samples) - - # Train / test split - start_event, end_event = self._train_test_split(switch_train_test_events, test_split) + parsed_thetas, n_samples_per_theta = self._parse_theta(theta, n_samples) + parsed_nus = self._parse_nu(nu, len(parsed_thetas)) + sets = self._build_sets([parsed_thetas], [parsed_nus]) # Extract information - x, _, (theta,) = self._extract_sample( - theta_sets_types=[theta_types], - theta_sets_values=[theta_values], - n_samples_per_theta=n_samples_per_theta, - start_event=start_event, - end_event=end_event, + x, _, (theta,), n_effective_samples = self._sample( + sets=sets, + n_samples_per_set=n_samples_per_theta, + use_train_events=switch_train_test_events, + test_split=test_split, + n_processes=n_processes, ) # Save data @@ -1107,9 +1001,9 @@ def extract_samples_test(self, theta, n_samples, folder, filename, test_split=0. np.save(folder + "/theta_" + filename + ".npy", theta) np.save(folder + "/x_" + filename + ".npy", x) - return x, theta + return x, theta, min(n_effective_samples) - def extract_cross_sections(self, theta): + def cross_sections(self, theta, nu=None): """ Calculates the total cross sections for all specified thetas. @@ -1118,14 +1012,21 @@ def extract_cross_sections(self, theta): ---------- theta : tuple Tuple (type, value) that defines the parameter point or prior over parameter points at which the cross - section is calculated. Pass the output of the functions `constant_benchmark_theta()`, - `multiple_benchmark_thetas()`, `constant_morphing_theta()`, `multiple_morphing_thetas()`, or - `random_morphing_thetas()`. + section is calculated. Pass the output of the functions `benchmark()`, + `benchmarks()`, `morphing_point()`, `morphing_points()`, or + `random_morphing_points()`. + + nu : tuple or None, optional + Tuple (type, value) that defines the nuisance parameter point or prior over nuisance parameter points at + which the cross section is calculated. Pass the output of the functions `benchmark()`, + `benchmarks()`, `morphing_point()`, `morphing_points()`, or + `random_morphing_points()`. Default valuee: None. Returns ------- thetas : ndarray - Parameter points with shape `(n_thetas, n_parameters)`. + Parameter points with shape `(n_thetas, n_parameters)` or + `(n_thetas, n_parameters + n_nuisance_parameters)`. xsecs : ndarray Total cross sections in pb with shape `(n_thetas, )`. @@ -1134,134 +1035,55 @@ def extract_cross_sections(self, theta): Statistical uncertainties on the total cross sections in pb with shape `(n_thetas, )`. """ - logger.info("Starting cross-section calculation") + parsed_thetas, _ = self._parse_theta(theta, None) + theta_values = np.asarray([self._get_theta_value(parsed_theta) for parsed_theta in parsed_thetas]) - # Total xsecs for benchmarks - xsecs_benchmarks = None - squared_weight_sum_benchmarks = None - - for obs, weights in madminer_event_loader(self.madminer_filename): - if xsecs_benchmarks is None: - xsecs_benchmarks = np.sum(weights, axis=0) - squared_weight_sum_benchmarks = np.sum(weights * weights, axis=0) - else: - xsecs_benchmarks += np.sum(weights, axis=0) - squared_weight_sum_benchmarks += np.sum(weights * weights, axis=0) - - # Parse thetas for evaluation - theta_types, theta_values, _ = parse_theta(theta, 1) - - # Loop over thetas - all_thetas = [] - all_xsecs = [] - all_xsec_uncertainties = [] - - for (theta_type, theta_value) in zip(theta_types, theta_values): - - if self.morpher is None and theta_type == "morphing": - raise RuntimeError("Theta defined through morphing, but no morphing setup has been loaded.") - - theta = get_theta_value(theta_type, theta_value, self.benchmarks) - theta_matrix = get_theta_benchmark_matrix(theta_type, theta_value, self.benchmarks, self.morpher) - - # Total xsec for this theta - xsec_theta = mdot(theta_matrix, xsecs_benchmarks) - rms_xsec_theta = mdot(theta_matrix * theta_matrix, squared_weight_sum_benchmarks) ** 0.5 - - all_thetas.append(theta) - all_xsecs.append(xsec_theta) - all_xsec_uncertainties.append(rms_xsec_theta) - - logger.debug("theta %s: xsec = (%s +/- %s) pb", theta, xsec_theta, rms_xsec_theta) - - # Return - all_thetas = np.array(all_thetas) - all_xsecs = np.array(all_xsecs) - all_xsec_uncertainties = np.array(all_xsec_uncertainties) - - return all_thetas, all_xsecs, all_xsec_uncertainties - - def extract_raw_data(self, theta=None, derivative=False): - - """ - Returns all events together with the benchmark weights (if theta is None) or weights for a given theta. - - Parameters - ---------- - theta : None or ndarray or str, optional - If None, the function returns all benchmark weights. If str, the function returns the weights for a given - benchmark name. If ndarray, it uses morphing to calculate the weights for this value of theta. Default - value: None. - - derivative : bool, optional - If True and if theta is not None, the derivative of the weights with respect to theta are returned. Default - value: False. - - Returns - ------- - x : ndarray - Observables with shape `(n_unweighted_samples, n_observables)`. - - weights : ndarray - If theta is None and derivative is False, benchmark weights with shape - `(n_unweighted_samples, n_benchmarks_phys)` in pb. If theta is not None and derivative is True, the gradient of - the weight for the given parameter with respect to theta with shape `(n_unweighted_samples, n_gradients)` - in pb. Otherwise, weights for the given parameter theta with shape `(n_unweighted_samples,)` in pb. - - """ - - x, weights_benchmarks = next(madminer_event_loader(self.madminer_filename, batch_size=None)) - - if theta is None: - return x, weights_benchmarks - - elif isinstance(theta, six.string_types): - i_benchmark = list(self.benchmarks.keys()).index(theta) - return x, weights_benchmarks[:, i_benchmark] - - elif derivative: - dtheta_matrix = get_dtheta_benchmark_matrix("morphing", theta, self.benchmarks, self.morpher) - - gradients_theta = mdot(dtheta_matrix, weights_benchmarks) # (n_gradients, n_samples) - gradients_theta = gradients_theta.T - - return x, gradients_theta - + if nu is not None: + parsed_nus = self._parse_nu(nu, len(parsed_thetas)) + nu_values = np.asarray([self._get_nu_value(parsed_nu for parsed_nu in parsed_nus)]) + param_values = np.hstack((theta_values, nu_values)) else: - theta_matrix = get_theta_benchmark_matrix("morphing", theta, self.benchmarks, self.morpher) + parsed_nus = None + param_values = theta_values - weights_theta = mdot(theta_matrix, weights_benchmarks) + xsecs, uncertainties = self.xsecs(thetas=parsed_thetas, nus=parsed_nus) - return x, weights_theta + return param_values, xsecs, uncertainties - def _extract_sample( + def _sample( self, - theta_sets_types, - theta_sets_values, - n_samples_per_theta, - sampling_theta_index=0, + sets, + n_samples_per_set, + sampling_index=0, augmented_data_definitions=None, - nuisance_score=False, - start_event=0, - end_event=None, + nuisance_score=True, + use_train_events=True, + test_split=0.2, + verbose="some", + n_processes=1, + update_patience=0.01, ): """ Low-level function for the extraction of information from the event samples. Do not use this function directly. + The sampling is organized in terms of "sets". For each set, a number of parameter points (thetas and nus) is + fixed, and `n_samples_per_theta` events are sampled from one of them. + Parameters ---------- - theta_sets_types : list of list of str - Each entry can be 'benchmark' or 'morphing'. + sets : list of list of tuples + The outer list goes over sets, the inner list goes over parameter points, the tuples have the form + (theta, nu). Here theta can be a str or int (for benchmarks) or ndarray (with morphing), while nu can be + None (for nominal value) or ndarray (for nuisance morphing). - theta_sets_values : list of list - Each entry is int and labels the benchmark index (if the corresponding - theta_sampling_types entry is 'benchmark') or a numpy array with the theta values - (of the corresponding theta_sampling_types entry is 'morphing') - - n_samples_per_theta : int + n_samples_per_set : int Number of samples to be drawn per entry in theta_sampling_types. + sampling_index : int + Marking the index of the theta set defined through thetas_types and + thetas_values that should be used for sampling. Default value: 0. + augmented_data_definitions : list of tuple or None Each tuple can either be ('ratio', num_theta, den_theta) or ('score', theta), where num_theta, den_theta, and theta are indexes marking @@ -1269,19 +1091,23 @@ def _extract_sample( used. Default value: None. nuisance_score : bool, optional - If True and if the sample contains nuisance parameters, any joint score in the augmented data definitions - is also calculated with respect to the nuisance parameters (evaluated at their default position). Default - value: False. + If True, any joint score in the augmented data definitions is also calculated with respect to the nuisance + parameters. Default value: True. - sampling_theta_index : int - Marking the index of the theta set defined through thetas_types and - thetas_values that should be used for sampling. Default value: 0. + use_train_events : bool, optional + Decides whether to use the train or test split of the events. Default value: True. + + test_split : float or None, optional + Fraction of events reserved for the evaluation sample (that will not be used for any training samples). + Default value: 0.2. - start_event : int - Index of first event to consider. Default value: 0. + n_processes : None or int, optional + If None or larger than 1, MadMiner will use multiprocessing to parallelize the sampling. In this case, + n_workers sets the number of jobs running in parallel, and None will use the number of CPUs. Default value: + 1. - end_event : int or None - Index of last event to consider. If None, use the last event. Default value: None. + update_patience : float, optional + Wait time (in s) between log updates with n_workers > 1 (or None). Default value: 0.01 Returns ------- @@ -1291,277 +1117,394 @@ def _extract_sample( augmented_data : list of ndarray Augmented data. - theta : list of ndarray + theta_values : list of ndarray Parameter values. """ logger.debug("Starting sample extraction") - assert n_samples_per_theta > 0, "Requested {} samples per theta!".format(n_samples_per_theta) - + # Check inputs if augmented_data_definitions is None: augmented_data_definitions = [] - logger.debug("Augmented data requested:") - for augmented_data_definition in augmented_data_definitions: - logger.debug(" %s", augmented_data_definition) - - # Nuisance parameters? - include_nuisance_parameters = self.include_nuisance_parameters and nuisance_score - - # Calculate total xsecs for benchmarks - xsecs_benchmarks = None - squared_weight_sum_benchmarks = None - n_observables = 0 - - for obs, weights in madminer_event_loader( - self.madminer_filename, - start=start_event, - end=end_event, - include_nuisance_parameters=include_nuisance_parameters, - benchmark_is_nuisance=self.benchmark_is_nuisance, - ): - # obs has shape (n_events, n_observables) - # weights has shape (n_events, n_benchmarks_phys) - # sampled_from_benchmark has shape (n_events,) - - if xsecs_benchmarks is None: - xsecs_benchmarks = np.sum(weights, axis=0) - squared_weight_sum_benchmarks = np.sum(weights * weights, axis=0) - else: - xsecs_benchmarks += np.sum(weights, axis=0) - squared_weight_sum_benchmarks += np.sum(weights * weights, axis=0) - - n_observables = obs.shape[1] + n_sets, n_params = self._check_sets(sets) - logger.debug("Benchmark cross sections [pb]: %s", xsecs_benchmarks) + # What needs to be calculated? + needs_gradients = self._check_gradient_need(augmented_data_definitions) - # Balance thetas - theta_sets_types, theta_sets_values = balance_thetas(theta_sets_types, theta_sets_values) - - # Check whether we need to calculate scores (which will require the gradients of the morphing matrices) - needs_gradients = False - for augmented_data_definition in augmented_data_definitions: - if augmented_data_definition[0] == "score": - needs_gradients = True + # Prepare outputs + all_x = [] + all_augmented_data = [[] for _ in augmented_data_definitions] + all_thetas = [[] for _ in range(n_params)] + all_nus = [[] for _ in range(n_params)] + all_effective_n_samples = [] - if self.morpher is None: - raise RuntimeError("Cannot calculate score without morphing setup!") + n_stats_warnings = 0 + n_neg_weights_warnings = 0 - # Consistency checks - n_benchmarks = xsecs_benchmarks.shape[0] - expected_n_benchmarks = self.n_benchmarks if include_nuisance_parameters else self.n_benchmarks_phys - if self.morphing_matrix is None: - if n_benchmarks != expected_n_benchmarks: - raise ValueError( - "Inconsistent numbers of benchmarks: {} in observations," - "{} in benchmark list".format(n_benchmarks, len(self.benchmarks)) - ) - else: - if n_benchmarks != expected_n_benchmarks or n_benchmarks < self.morphing_matrix.shape[0]: - raise ValueError( - "Inconsistent numbers of benchmarks: {} in observations, {} in benchmark list, " - "{} in morphing matrix".format(n_benchmarks, len(self.benchmarks), self.morphing_matrix.shape[0]) - ) + # Multiprocessing approach + if n_processes is None or n_processes > 1: + if n_processes is None: + n_processes = multiprocessing.cpu_count() - if n_observables != len(self.observables): - raise ValueError( - "Inconsistent numbers of observables: {} in observations," - "{} in observable list".format(n_observables, len(self.observables)) + job = partial( + self._sample_set, + n_samples=n_samples_per_set, + augmented_data_definitions=augmented_data_definitions, + sampling_index=sampling_index, + needs_gradients=needs_gradients, + use_train_events=use_train_events, + test_split=test_split, + nuisance_score=nuisance_score, + n_stats_warnings=1000, + n_neg_weights_warnings=1000, ) - n_thetas = len(theta_sets_types) - assert n_thetas == len(theta_sets_values) - # Sets (within each set, all thetas (sampling, numerator, ...) have a constant value) - n_sets = len(theta_sets_types[sampling_theta_index]) - for theta_types, theta_values in zip(theta_sets_types, theta_sets_values): - assert n_sets == len(theta_types) == len(theta_values) + logger.info("Starting sampling jobs in parallel, using %s processes", n_processes) - # Number of samples to be drawn - if not isinstance(n_samples_per_theta, collections.Iterable): - n_samples_per_theta = [n_samples_per_theta] * n_sets - elif len(n_samples_per_theta) == 1: - n_samples_per_theta = [n_samples_per_theta[0]] * n_sets + pool = multiprocessing.Pool(processes=n_processes) + r = pool.map_async(job, sets, chunksize=1) - # Prepare output - all_x = [] - all_augmented_data = [[] for _ in augmented_data_definitions] - all_thetas = [[] for _ in range(n_thetas)] - all_effective_n_samples = [] + next_verbose = 0 + verbose_steps = n_sets // 10 + + while not r.ready(): + n_done = max(n_sets - r._number_left * r._chunksize, 0) + if n_done >= next_verbose: + logger.info("%s / %s jobs done", max(n_sets - r._number_left * r._chunksize, 0), n_sets) + while next_verbose <= n_done: + next_verbose += verbose_steps + time.sleep(update_patience) - n_statistics_warnings = 0 - n_negative_weights_warnings = 0 + r.wait() - # Main loop over thetas - for i_set in range(n_sets): + logger.info("All jobs done!") - # Setup for set - n_samples = n_samples_per_theta[i_set] + for x, thetas, nus, augmented_data, eff_n_samples, _, _ in r.get(): + all_x.append(x) + for i, values in enumerate(augmented_data): + all_augmented_data[i].append(values) + for i, values in enumerate(thetas): + all_thetas[i].append(values) + for i, values in enumerate(nus): + all_nus[i].append(values) + all_effective_n_samples.append(eff_n_samples) - theta_types = [t[i_set] for t in theta_sets_types] - theta_values = [t[i_set] for t in theta_sets_values] + # Serial approach + else: + logger.info("Starting sampling serially") + + # Verbosity + if verbose == "all": # Print output after every epoch + n_sets_verbose = 1 + elif verbose == "many": # Print output after 2%, 4%, ..., 100% progress + n_sets_verbose = max(int(round(n_sets / 50, 0)), 1) + elif verbose == "some": # Print output after 10%, 20%, ..., 100% progress + n_sets_verbose = max(int(round(n_sets / 20, 0)), 1) + elif verbose == "few": # Print output after 20%, 40%, ..., 100% progress + n_sets_verbose = max(int(round(n_sets / 5, 0)), 1) + elif verbose == "none": # Never print output + n_sets_verbose = n_sets + 2 + else: + raise ValueError("Unknown value %s for keyword verbose", verbose) + logger.debug("Will print training progress every %s sets", n_sets_verbose) + + # Loop over sets + for i_set, set_ in enumerate(sets): + if (i_set + 1) % n_sets_verbose == 0: + logger.info("Sampling from parameter point %s / %s", i_set + 1, n_sets) + else: + logger.debug("Sampling from parameter point %s / %s", i_set + 1, n_sets) + + x, thetas, nus, augmented_data, eff_n_samples, n_stats_warnings, n_neg_weights_warnings = self._sample_set( + set_, + n_samples=n_samples_per_set, + augmented_data_definitions=augmented_data_definitions, + sampling_index=sampling_index, + needs_gradients=needs_gradients, + use_train_events=use_train_events, + test_split=test_split, + nuisance_score=nuisance_score, + n_stats_warnings=n_stats_warnings, + n_neg_weights_warnings=n_neg_weights_warnings, + ) - if self.morpher is None and "morphing" in theta_types: - raise RuntimeError("Theta defined through morphing, but no morphing setup has been loaded.") + all_x.append(x) + for i, values in enumerate(augmented_data): + all_augmented_data[i].append(values) + for i, values in enumerate(thetas): + all_thetas[i].append(values) + for i, values in enumerate(nus): + all_nus[i].append(values) + all_effective_n_samples.append(eff_n_samples) - # Parse thetas and calculate the w_c(theta) for them - thetas = [] - theta_matrices = [] - theta_gradient_matrices = [] + # Combine and return results + all_x = np.vstack(all_x) + for i, values in enumerate(all_thetas): + all_thetas[i] = np.vstack(values) + for i, values in enumerate(all_nus): + all_nus[i] = np.vstack(values) + for i, values in enumerate(all_augmented_data): + all_augmented_data[i] = np.vstack(values) + all_effective_n_samples = np.array(all_effective_n_samples) + all_thetas = self._combine_thetas_nus(all_thetas, all_nus) - logger.debug("Drawing %s events for the following thetas:", n_samples) + # Report effective number of samples + self._report_effective_n_samples(all_effective_n_samples) + + return all_x, all_augmented_data, all_thetas, all_effective_n_samples + + @staticmethod + def _check_sets(sets): + n_sets = len(sets) + n_params = None + for set_ in sets: + if n_params is None: + n_params = len(set_) + assert len(set_) == n_params + for param_point in set_: + assert len(param_point) == 2 + + return n_sets, n_params + + @staticmethod + def _check_gradient_need(augmented_data_definitions): + for definition in augmented_data_definitions: + if definition[0] == "score": + return True + return False + + def _sample_set( + self, + set_, + n_samples, + augmented_data_definitions, + sampling_index=0, + needs_gradients=True, + nuisance_score=True, + use_train_events=True, + test_split=0.2, + n_stats_warnings=0, + n_neg_weights_warnings=0, + ): + # Parse thetas and nus + thetas, nus = [], [] + theta_values, nu_values = [], [] + theta_matrices, theta_gradient_matrices = [], [] - for i_theta, (theta_type, theta_value) in enumerate(zip(theta_types, theta_values)): - theta = get_theta_value(theta_type, theta_value, self.benchmarks) - theta = np.broadcast_to(theta, (n_samples, theta.size)) - thetas.append(theta) + logger.debug("Drawing %s events for the following parameter points:", n_samples) - theta_matrices.append( - get_theta_benchmark_matrix(theta_type, theta_value, self.benchmarks, self.morpher) - ) - if needs_gradients: - theta_gradient_matrices.append( - get_dtheta_benchmark_matrix(theta_type, theta_value, self.benchmarks, self.morpher) - ) + for i_param, (theta, nu) in enumerate(set_): + thetas.append(theta) + nus.append(nu) - logger.debug( - " theta %s = %s%s", i_theta, theta[0, :], " (sampling)" if i_theta == sampling_theta_index else "" - ) + theta_value = self._get_theta_value(theta) + theta_value = np.broadcast_to(theta_value, (n_samples, theta_value.size)) + theta_values.append(theta_value) - sampling_theta_matrix = theta_matrices[sampling_theta_index] + if nu is None: + nu_value = None + nu_values.append([[None] for _ in range(n_samples)]) + else: + nu_value = self._get_nu_value(nu) + nu_values.append(np.broadcast_to(nu_value, (n_samples, nu_value.size))) - # Total xsec for sampling theta - xsec_sampling_theta = mdot(sampling_theta_matrix, xsecs_benchmarks) - rms_xsec_sampling_theta = ( - mdot(sampling_theta_matrix * sampling_theta_matrix, squared_weight_sum_benchmarks) - ) ** 0.5 + theta_matrices.append(self._get_theta_benchmark_matrix(theta)) + if needs_gradients: + theta_gradient_matrices.append(self._get_dtheta_benchmark_matrix(theta)) - if rms_xsec_sampling_theta > 0.1 * xsec_sampling_theta: - n_statistics_warnings += 1 + if i_param == sampling_index: + logger.debug(" %s: theta = %s, nu = %s (sampling)", i_param, theta_value[0, :], nu_value) + else: + logger.debug(" %s: theta = %s, nu = %s", i_param, theta_value[0, :], nu_value) - if n_statistics_warnings <= 1: - logger.warning( - "Large statistical uncertainty on the total cross section for theta = %s: " - "(%4f +/- %4f) pb. Skipping these warnings in the future...", - thetas[sampling_theta_index][0], - xsec_sampling_theta, - rms_xsec_sampling_theta, - ) + # Cross sections + xsecs, xsec_uncertainties = self.xsecs( + thetas, nus, events="train" if use_train_events else "test", test_split=test_split + ) + if needs_gradients: + xsec_gradients = self.xsec_gradients( + thetas, + nus, + gradients="all" if nuisance_score else "theta", + events="train" if use_train_events else "test", + test_split=test_split, + ) + else: + xsec_gradients = None + + # Report large uncertainties + if xsec_uncertainties[sampling_index] > 0.1 * xsecs[sampling_index]: + n_stats_warnings += 1 + if n_stats_warnings <= 1: + logger.warning( + "Large statistical uncertainty on the total cross section when sampling from theta = %s: " + "(%4f +/- %4f) pb (%s %%). Skipping these warnings in the future...", + theta_values[sampling_index][0], + xsecs[sampling_index], + xsec_uncertainties[sampling_index], + 100.0 * xsec_uncertainties[sampling_index] / xsecs[sampling_index], + ) - # Prepare output - samples_done = np.zeros(n_samples, dtype=np.bool) - samples_x = np.zeros((n_samples, n_observables)) - samples_augmented_data = [] - for definition in augmented_data_definitions: - if definition[0] == "ratio": - samples_augmented_data.append(np.zeros((n_samples, 1))) - elif definition[0] == "score": - samples_augmented_data.append(np.zeros((n_samples, self.n_parameters))) - elif definition[0] == "nuisance_score": - samples_augmented_data.append(np.zeros((n_samples, self.n_nuisance_parameters))) - - largest_weight = 0.0 - - # Main sampling loop - while not np.all(samples_done): - - # Draw random numbers in [0, 1] - u = np.random.rand(n_samples) # Shape: (n_samples,) - - # Loop over weighted events - cumulative_p = np.array([0.0]) - - for x_batch, weights_benchmarks_batch in madminer_event_loader( - self.madminer_filename, start=start_event, end=end_event - ): - # Evaluate p(x | sampling theta) - weights_theta = mdot(sampling_theta_matrix, weights_benchmarks_batch) # Shape (n_batch_size,) - p_theta = weights_theta / xsec_sampling_theta # Shape: (n_batch_size,) - - # Handle negative weights (should be rare) - n_negative_weights = np.sum(p_theta < 0.0) - if n_negative_weights > 0: - n_negative_weights_warnings += 1 - # n_negative_benchmark_weights = np.sum(weights_benchmarks_batch < 0.0) - - if n_negative_weights_warnings <= 3: - logger.warning( - "For this value of theta, %s / %s events have negative weight and will be ignored", - n_negative_weights, - p_theta.size, - ) - if n_negative_weights_warnings == 3: - logger.warning("Skipping warnings about negative weights in the future...") - - # filter_negative_weights = p_theta < 0.0 - # for weight_theta_neg, weight_benchmarks_neg in zip( - # weights_theta[filter_negative_weights], weights_benchmarks_batch[filter_negative_weights] - # ): - # logger.debug( - # " weight(theta): %s, benchmark weights: %s", weight_theta_neg, weight_benchmarks_neg - # ) - - p_theta[p_theta < 0.0] = 0.0 - - # Remember largest weights (to calculate effective number of samples) - largest_weight = max(largest_weight, np.max(p_theta)) - - # Calculate cumulative p (summing up all events until here) - cumulative_p = cumulative_p.flatten()[-1] + np.cumsum(p_theta) # Shape: (n_batch_size,) - - # When cumulative_p hits u, we store the events - indices = np.searchsorted(cumulative_p, u, side="left").flatten() - # Shape: (n_samples,), values: [0, ..., n_batch_size] - - found_now = np.invert(samples_done) & (indices < len(cumulative_p)) # Shape: (n_samples,) - samples_x[found_now] = x_batch[indices[found_now]] - samples_done[found_now] = True - - # Extract augmented data - relevant_augmented_data = calculate_augmented_data( - augmented_data_definitions, - weights_benchmarks_batch[indices[found_now], :], - xsecs_benchmarks, - theta_matrices, - theta_gradient_matrices, - nuisance_morpher=self.nuisance_morpher, + # Prepare output + done = np.zeros(n_samples, dtype=np.bool) + x = np.zeros((n_samples, self.n_observables)) + augmented_data = [] + for definition in augmented_data_definitions: + if definition[0] == "ratio": + augmented_data.append(np.zeros((n_samples, 1))) + elif definition[0] == "score": + if nuisance_score: + augmented_data.append(np.zeros((n_samples, self.n_parameters + self.n_nuisance_parameters))) + else: + augmented_data.append(np.zeros((n_samples, self.n_parameters))) + largest_event_probability = 0.0 + + # Main sampling loop + start_event, end_event, correction_factor = self._train_test_split(use_train_events, test_split) + while not np.all(done): + # Draw random numbers in [0, 1] + u = np.random.rand(n_samples) # Shape: (n_samples,) + cumulative_p = np.array([0.0]) + + # Loop over weighted events + for x_batch, weights_benchmarks_batch in madminer_event_loader( + self.madminer_filename, start=start_event, end=end_event + ): + weights_benchmarks_batch *= correction_factor + + # Weights + weights = self._weights(thetas, nus, weights_benchmarks_batch, theta_matrices) + if needs_gradients: + weight_gradients = self._weight_gradients( + thetas, + nus, + weights_benchmarks_batch, + gradients="all" if nuisance_score else "theta", + theta_matrices=theta_matrices, + theta_gradient_matrices=theta_gradient_matrices, ) + else: + weight_gradients = None + + # Evaluate p(x | sampling theta) + p_sampling = weights[sampling_index] / xsecs[sampling_index] # Shape: (n_batch_size,) + + # Handle negative weights (should be rare) + n_negative_weights = np.sum(p_sampling < 0.0) + if n_negative_weights > 0: + n_neg_weights_warnings += 1 + if n_neg_weights_warnings <= 3: + logger.warning( + "For this value of theta, %s / %s events have negative weight and will be ignored", + n_negative_weights, + p_sampling.size, + ) + if n_neg_weights_warnings == 3: + logger.warning("Skipping warnings about negative weights in the future...") + p_sampling[p_sampling < 0.0] = 0.0 + + # Remember largest weights (to calculate effective number of samples) + largest_event_probability = max(largest_event_probability, np.max(p_sampling)) + + # Calculate cumulative p (summing up all events until here) + cumulative_p = cumulative_p.flatten()[-1] + np.cumsum(p_sampling) # Shape: (n_batch_size,) + + # When cumulative_p hits u, we store the events + indices = np.searchsorted(cumulative_p, u, side="left").flatten() + # Shape: (n_samples,), values: [0, ..., n_batch_size] + + found_now = np.invert(done) & (indices < len(cumulative_p)) # Shape: (n_samples,) + x[found_now] = x_batch[indices[found_now]] + done[found_now] = True + + # Extract augmented data + relevant_augmented_data = self._calculate_augmented_data( + augmented_data_definitions=augmented_data_definitions, + weights=weights[:, indices[found_now]], + weight_gradients=None if weight_gradients is None else weight_gradients[:, :, indices[found_now]], + xsecs=xsecs, + xsec_gradients=xsec_gradients, + ) + for i, this_relevant_augmented_data in enumerate(relevant_augmented_data): + augmented_data[i][found_now] = this_relevant_augmented_data - for i, this_relevant_augmented_data in enumerate(relevant_augmented_data): - samples_augmented_data[i][found_now] = this_relevant_augmented_data - - if np.all(samples_done): - break + # Finished? + if np.all(done): + break - # Cross-check cumulative probabilities at end - logger.debug(" Cumulative probability (should be close to 1): %s", cumulative_p[-1]) + # Cross-check cumulative probabilities at end + logger.debug(" Cumulative probability (should be close to 1): %s", cumulative_p[-1]) - # Check that we got 'em all, otherwise repeat - if not np.all(samples_done): - logger.debug( - " After full pass through event files, {} / {} samples not found, u = {}".format( - np.sum(np.invert(samples_done)), samples_done.size, u[np.invert(samples_done)] - ) + # Check that we got 'em all, otherwise repeat + if not np.all(done): + logger.debug( + " After full pass through event files, {} / {} samples not found, with u = {}".format( + np.sum(np.invert(done)), done.size, u[np.invert(done)] ) + ) - all_x.append(samples_x) - for i, theta in enumerate(thetas): - all_thetas[i].append(theta) - for i, this_samples_augmented_data in enumerate(samples_augmented_data): - all_augmented_data[i].append(this_samples_augmented_data) - all_effective_n_samples.append(1.0 / max(1.0e-12, largest_weight)) + n_eff_samples = 1.0 / max(1.0e-12, largest_event_probability) - # Combine and return results - all_x = np.vstack(all_x) - for i in range(n_thetas): - all_thetas[i] = np.vstack(all_thetas[i]) - for i in range(len(all_augmented_data)): - all_augmented_data[i] = np.vstack(all_augmented_data[i]) - all_effective_n_samples = np.array(all_effective_n_samples) + return x, theta_values, nu_values, augmented_data, n_eff_samples, n_stats_warnings, n_neg_weights_warnings - # Report effective number of samples - if n_sets > 1: + @staticmethod + def _calculate_augmented_data( + augmented_data_definitions, + weights, # shape (n_thetas, n_events) + weight_gradients, # grad_theta dsigma(theta, nu) with shape (n_thetas, n_gradients, n_events) + xsecs, # shape (n_thetas,) + xsec_gradients, # grad_theta sigma(theta, nu) with shape (n_params, n_gradients) + ): + augmented_data = [] + for definition in augmented_data_definitions: + if definition[0] == "ratio": + _, i_num, i_den = definition + ratio = (weights[i_num] / xsecs[i_num]) / (weights[i_den] / xsecs[i_den]) + ratio = ratio.reshape((-1, 1)) # (n_samples, 1) + augmented_data.append(ratio) + elif definition[0] == "score": + _, i = definition + score = weight_gradients[i, :, :] / weights[i, np.newaxis, :] # (n_gradients, n_samples) + score = score - xsec_gradients[i, :, np.newaxis] / xsecs[i, np.newaxis, np.newaxis] + score = score.T # (n_samples, n_gradients) + augmented_data.append(score) + else: + raise ValueError("Unknown augmented data type {}".format(definition[0])) + + return augmented_data + + def _combine_thetas_nus(self, all_thetas, all_nus): + n_thetas = len(all_thetas) + assert n_thetas == len(all_nus) + + # all_nus is a list of a list of (None or ndarray) + # Figure out if there's anything nontrivial in there + add_nuisance_params = False + for nus in all_nus: + if self._any_nontrivial_nus(nus): + add_nuisance_params = True + + # No nuisance params? + if not add_nuisance_params or self.nuisance_morpher is None or self.n_nuisance_parameters == 0: + return all_thetas + + all_combined = [] + for thetas, nus in zip(all_thetas, all_nus): + combined = [] + if nus is None: + nus = [None for _ in range(thetas)] + for theta, nu in zip(thetas, nus): + if nu is None or None in nu: + nu = np.zeros(self.n_nuisance_parameters) + combined.append(np.hstack((theta, nu))) + all_combined.append(np.asarray(combined)) + return all_combined + + @staticmethod + def _report_effective_n_samples(all_effective_n_samples): + if len(all_effective_n_samples) > 1: logger.info( "Effective number of samples: mean %s, with individual thetas ranging from %s to %s", np.mean(all_effective_n_samples), @@ -1572,47 +1515,345 @@ def _extract_sample( else: logger.info("Effective number of samples: %s", all_effective_n_samples[0]) - return all_x, all_augmented_data, all_thetas + @staticmethod + def _parse_theta(theta, n_samples): + theta_type_in = theta[0] + theta_value_in = theta[1] - def _train_test_split(self, train, test_split): - """ - Returns the start and end event for train samples (train = True) or test samples (train = False). + if theta_type_in == "benchmark": + thetas_out = [theta_value_in] + if n_samples is None: + n_samples_per_theta = 1 + else: + n_samples_per_theta = n_samples - Parameters - ---------- - train : bool - True if training data is generated, False if test data is generated. + elif theta_type_in == "benchmarks": + n_benchmarks = len(theta_value_in) + if n_samples is None: + n_samples_per_theta = 1 + else: + n_samples_per_theta = max(int(round(n_samples / n_benchmarks, 0)), 1) + thetas_out = theta_value_in - test_split : float - Fraction of events reserved for testing. + elif theta_type_in == "morphing_point": + thetas_out = [np.asarray(theta_value_in)] + if n_samples is None: + n_samples_per_theta = 1 + else: + n_samples_per_theta = n_samples - Returns - ------- - start_event : int - Index of the first unweighted event to consider. + elif theta_type_in == "morphing_points": + n_benchmarks = len(theta_value_in) + if n_samples is None: + n_samples_per_theta = 1 + else: + n_samples_per_theta = max(int(round(n_samples / n_benchmarks, 0)), 1) + thetas_out = theta_value_in + + elif theta_type_in == "random_morphing_points": + n_benchmarks, priors = theta_value_in + if n_benchmarks is None or n_benchmarks <= 0 or (n_samples is not None and n_benchmarks > n_samples): + n_benchmarks = n_samples + if n_samples is None: + n_samples_per_theta = 1 + else: + n_samples_per_theta = max(int(round(n_samples / n_benchmarks, 0)), 1) + + thetas_out = [] + for prior in priors: + if prior[0] == "flat": + prior_min = prior[1] + prior_max = prior[2] + thetas_out.append(prior_min + (prior_max - prior_min) * np.random.rand(n_benchmarks)) + elif prior[0] == "gaussian": + prior_mean = prior[1] + prior_std = prior[2] + thetas_out.append(np.random.normal(loc=prior_mean, scale=prior_std, size=n_benchmarks)) + else: + raise ValueError("Unknown prior {}".format(prior)) + thetas_out = np.array(thetas_out).T - end_event : int - Index of the last unweighted event to consider. + else: + raise ValueError("Unknown theta specification {}".format(theta)) - """ - if train: - start_event = 0 + return thetas_out, n_samples_per_theta - if test_split is None or test_split <= 0.0 or test_split >= 1.0: - end_event = None - else: - end_event = int(round((1.0 - test_split) * self.n_samples, 0)) - if end_event < 0 or end_event > self.n_samples: - raise ValueError("Irregular train / test split: sample {} / {}", end_event, self.n_samples) + def _parse_nu(self, nu, n_thetas): + if nu is None: + nu_type_in = "nominal" + nu_value_in = None + else: + nu_type_in = nu[0] + nu_value_in = nu[1] + + if nu_type_in == "nominal": + nu_out = [None for _ in range(n_thetas)] + + elif nu_type_in == "iid": + priors = [nu_value_in for _ in range(self.n_nuisance_parameters)] + return self._parse_nu(("random_morphing_points", (None, priors)), n_thetas) + + elif nu_type_in == "morphing_point": + nu_out = np.asarray([nu_value_in for _ in range(n_thetas)]) + + elif nu_type_in == "morphing_points": + n_nus = len(nu_value_in) + nu_out = np.asarray([nu_value_in[i % n_nus] for i in range(n_thetas)]) + + elif nu_type_in == "random_morphing_points": + _, priors = nu_value_in + + nu_out = [] + for prior in priors: + if prior[0] == "flat": + prior_min = prior[1] + prior_max = prior[2] + nu_out.append(prior_min + (prior_max - prior_min) * np.random.rand(n_thetas)) + elif prior[0] == "gaussian": + prior_mean = prior[1] + prior_std = prior[2] + nu_out.append(np.random.normal(loc=prior_mean, scale=prior_std, size=n_thetas)) + else: + raise ValueError("Unknown prior {}".format(prior)) + nu_out = np.array(nu_out).T else: - if test_split is None or test_split <= 0.0 or test_split >= 1.0: - start_event = 0 + raise ValueError("Unknown nu specification {}".format(nu)) + + return nu_out + + @staticmethod + def _build_sets(thetas, nus): + if len(nus) != len(thetas): + raise RuntimeError("Mismatching thetas and nus: {} vs {}".format(len(thetas), len(nus))) + + n_sets = max([len(param) for param in thetas + nus]) + sets = [[] for _ in range(n_sets)] + + for (theta, nu) in zip(thetas, nus): + n_theta_sets_before = len(theta) + n_nu_sets_before = len(nu) + + for i_set in range(n_sets): + sets[i_set].append((theta[i_set % n_theta_sets_before], nu[i_set % n_nu_sets_before])) + + return sets + + +def combine_and_shuffle(input_filenames, output_filename, k_factors=None, overwrite_existing_file=True): + """ + Combines multiple MadMiner files into one, and shuffles the order of the events. + + Note that this function assumes that all samples are generated with the same setup, including identical benchmarks + (and thus morphing setup). If it is used with samples with different settings, there will be wrong results! + There are no explicit cross checks in place yet! + + Parameters + ---------- + input_filenames : list of str + List of paths to the input MadMiner files. + + output_filename : str + Path to the combined MadMiner file. + + k_factors : float or list of float, optional + Multiplies the weights in input_filenames with a universal factor (if k_factors is a float) or with independent + factors (if it is a list of float). Default value: None. + + overwrite_existing_file : bool, optional + If True and if the output file exists, it is overwritten. Default value: True. + + Returns + ------- + None + + """ + + logger.debug("Combining and shuffling samples") + + if len(input_filenames) > 1: + logger.warning( + "Careful: this tool assumes that all samples are generated with the same setup, including" + " identical benchmarks (and thus morphing setup). If it is used with samples with different" + " settings, there will be wrong results! There are no explicit cross checks in place yet." + ) + + # k factors + if k_factors is None: + k_factors = [1.0 for _ in input_filenames] + elif isinstance(k_factors, float): + k_factors = [k_factors for _ in input_filenames] + + # Copy first file to output_filename + logger.info("Copying setup from %s to %s", input_filenames[0], output_filename) + + # TODO: More memory efficient strategy + + # Load events + all_observations = None + all_weights = None + + for i, (filename, k_factor) in enumerate(zip(input_filenames, k_factors)): + logger.info( + "Loading samples from file %s / %s at %s, multiplying weights with k factor %s", + i + 1, + len(input_filenames), + filename, + k_factor, + ) + + for observations, weights in madminer_event_loader(filename): + if all_observations is None: + all_observations = observations + all_weights = k_factor * weights else: - start_event = int(round((1.0 - test_split) * self.n_samples, 0)) + 1 - if start_event < 0 or start_event > self.n_samples: - raise ValueError("Irregular train / test split: sample {} / {}", start_event, self.n_samples) + all_observations = np.vstack((all_observations, observations)) + all_weights = np.vstack((all_weights, k_factor * weights)) + + # Shuffle + all_observations, all_weights = shuffle(all_observations, all_weights) + + # Save result + save_preformatted_events_to_madminer_file( + filename=output_filename, + observations=all_observations, + weights=all_weights, + copy_setup_from=input_filenames[0], + overwrite_existing_samples=overwrite_existing_file, + ) + + +def benchmark(benchmark_name): + """ + Utility function to be used as input to various SampleAugmenter functions, specifying a single parameter benchmark. + + Parameters + ---------- + benchmark_name : str + Name of the benchmark (as in `madminer.core.MadMiner.add_benchmark`) + + + Returns + ------- + output : tuple + Input to various SampleAugmenter functions - end_event = None + """ + return "benchmark", benchmark_name + + +def benchmarks(benchmark_names): + """ + Utility function to be used as input to various SampleAugmenter functions, specifying multiple parameter benchmarks. + + Parameters + ---------- + benchmark_names : list of str + List of names of the benchmarks (as in `madminer.core.MadMiner.add_benchmark`) + + + Returns + ------- + output : tuple + Input to various SampleAugmenter functions + + """ + return "benchmarks", benchmark_names - return start_event, end_event + +def morphing_point(theta): + """ + Utility function to be used as input to various SampleAugmenter functions, specifying a single parameter point theta + in a morphing setup. + + Parameters + ---------- + theta : ndarray or list + Parameter point with shape `(n_parameters,)` + + Returns + ------- + output : tuple + Input to various SampleAugmenter functions + + """ + return "morphing_point", np.asarray(theta) + + +def morphing_points(thetas): + """ + Utility function to be used as input to various SampleAugmenter functions, specifying multiple parameter points + theta in a morphing setup. + + Parameters + ---------- + thetas : ndarray or list of lists or list of ndarrays + Parameter points with shape `(n_thetas, n_parameters)` + + Returns + ------- + output : tuple + Input to various SampleAugmenter functions + + """ + return "morphing_points", [np.asarray(theta) for theta in thetas] + + +def random_morphing_points(n_thetas, priors): + """ + Utility function to be used as input to various SampleAugmenter functions, specifying random parameter points + sampled from a prior in a morphing setup. + + Parameters + ---------- + n_thetas : int + Number of parameter points to be sampled + + priors : list of tuples + Priors for each parameter is characterized by a tuple of the form `(prior_shape, prior_param_0, prior_param_1)`. + Currently, the supported prior_shapes are `flat`, in which case the two other parameters are the lower and upper + bound of the flat prior, and `gaussian`, in which case they are the mean and standard deviation of a Gaussian. + + Returns + ------- + output : tuple + Input to various SampleAugmenter functions + + """ + return "random_morphing_points", (n_thetas, priors) + + +def iid_nuisance_parameters(shape="gaussian", param0=0.0, param1=1.0): + """ + Utility function to be used as input to various SampleAugmenter functions, specifying that nuisance parameters are + fixed at their nominal valuees. + + Parameters + ---------- + prior : tuple + Prior for all nuisance parameters with form `(prior_shape, prior_param_0, prior_param_1)`. + Currently, the supported prior_shapes are `flat`, in which case the two other parameters are the lower and upper + bound of the flat prior, and `gaussian`, in which case they are the mean and standard deviation of a Gaussian. + + Returns + ------- + output : tuple + Input to various SampleAugmenter functions + + """ + return "iid", (shape, param0, param1) + + +def nominal_nuisance_parameters(): + """ + Utility function to be used as input to various SampleAugmenter functions, specifying that nuisance parameters are + fixed at their nominal valuees. + + + Returns + ------- + output : tuple + Input to various SampleAugmenter functions + + """ + return "nominal", None diff --git a/madminer/utils/analysis.py b/madminer/utils/analysis.py deleted file mode 100644 index b8a7cc763..000000000 --- a/madminer/utils/analysis.py +++ /dev/null @@ -1,207 +0,0 @@ -from __future__ import absolute_import, division, print_function, unicode_literals - -import numpy as np -import six -import logging - -logger = logging.getLogger(__name__) - - -def get_theta_value(theta_type, theta_value, benchmarks): - if theta_type == "benchmark": - benchmark = benchmarks[theta_value] - benchmark_theta = np.array([benchmark[key] for key in benchmark]) - return benchmark_theta - - elif theta_type == "morphing": - return theta_value - - else: - raise ValueError("Unknown theta {}".format(theta_type)) - - -def get_theta_benchmark_matrix(theta_type, theta_value, benchmarks, morpher=None): - """Calculates vector A such that dsigma(theta) = A * dsigma_benchmarks""" - - if theta_type == "benchmark": - n_benchmarks = len(benchmarks) - index = list(benchmarks).index(theta_value) - theta_matrix = np.zeros(n_benchmarks) - theta_matrix[index] = 1.0 - - elif theta_type == "morphing": - theta_matrix = morpher.calculate_morphing_weights(theta_value) - - else: - raise ValueError("Unknown theta {}".format(theta_type)) - - return theta_matrix - - -def get_dtheta_benchmark_matrix(theta_type, theta_value, benchmarks, morpher=None): - """Calculates matrix A_ij such that d dsigma(theta) / d theta_i = A_ij * dsigma (benchmark j)""" - - if theta_type == "benchmark": - if morpher is None: - raise RuntimeError("Cannot calculate score without morphing") - - theta = benchmarks[theta_value] - theta = np.array([value for _, value in six.iteritems(theta)]) - - return get_dtheta_benchmark_matrix("morphing", theta, benchmarks, morpher) - - elif theta_type == "morphing": - if morpher is None: - raise RuntimeError("Cannot calculate score without morphing") - - dtheta_matrix = morpher.calculate_morphing_weight_gradient( - theta_value - ) # Shape (n_parameters, n_benchmarks_phys) - - else: - raise ValueError("Unknown theta {}".format(theta_type)) - - return dtheta_matrix - - -def calculate_augmented_data( - augmented_data_definitions, - weights_benchmarks, - xsecs_benchmarks, - theta_matrices, - theta_gradient_matrices, - nuisance_morpher=None, -): - """Extracts augmented data from benchmark weights""" - - augmented_data = [] - - for definition in augmented_data_definitions: - - if definition[0] == "ratio": - i_num = definition[1] - i_den = definition[2] - - dsigma_num = mdot(theta_matrices[i_num], weights_benchmarks) - sigma_num = mdot(theta_matrices[i_num], xsecs_benchmarks) - dsigma_den = mdot(theta_matrices[i_den], weights_benchmarks) - sigma_den = mdot(theta_matrices[i_den], xsecs_benchmarks) - - ratio = (dsigma_num / sigma_num) / (dsigma_den / sigma_den) - ratio = ratio.reshape((-1, 1)) - - augmented_data.append(ratio) - - elif definition[0] == "score": - i = definition[1] - - gradient_dsigma = mdot(theta_gradient_matrices[i], weights_benchmarks) # (n_gradients, n_samples) - gradient_sigma = mdot(theta_gradient_matrices[i], xsecs_benchmarks) # (n_gradients,) - - dsigma = mdot(theta_matrices[i], weights_benchmarks) # (n_samples,) - sigma = mdot(theta_matrices[i], xsecs_benchmarks) # scalar - - score = gradient_dsigma / dsigma # (n_gradients, n_samples) - score = score.T # (n_samples, n_gradients) - score = score - np.broadcast_to(gradient_sigma / sigma, score.shape) # (n_samples, n_gradients) - - augmented_data.append(score) - - elif definition[0] == "nuisance_score": - a_weights = nuisance_morpher.calculate_a(weights_benchmarks) - a_xsec = nuisance_morpher.calculate_a(xsecs_benchmarks[np.newaxis, :]) - - nuisance_score = a_weights - a_xsec # Shape (n_nuisance_parameters, n_samples) - nuisance_score = nuisance_score.T # Shape (n_samples, n_nuisance_parameters) - - logger.debug("Nuisance score: shape %s, content %s", nuisance_score.shape, nuisance_score) - - augmented_data.append(nuisance_score) - - else: - raise ValueError("Unknown augmented data type {}".format(definition[0])) - - return augmented_data - - -def parse_theta(theta, n_samples): - theta_type_in = theta[0] - theta_value_in = theta[1] - - if theta_type_in == "benchmark": - theta_types = ["benchmark"] - theta_values = [theta_value_in] - n_samples_per_theta = n_samples - - elif theta_type_in == "benchmarks": - n_benchmarks = len(theta_value_in) - theta_types = ["benchmark"] * n_benchmarks - theta_values = theta_value_in - n_samples_per_theta = int(round(n_samples / n_benchmarks, 0)) - - elif theta_type_in == "theta": - theta_types = ["morphing"] - theta_values = [theta_value_in] - n_samples_per_theta = n_samples - - elif theta_type_in == "thetas": - n_benchmarks = len(theta_value_in) - theta_types = ["morphing"] * n_benchmarks - theta_values = theta_value_in - n_samples_per_theta = int(round(n_samples / n_benchmarks, 0)) - - elif theta_type_in == "random": - n_benchmarks, priors = theta_value_in - - if n_benchmarks is None or n_benchmarks <= 0: - n_benchmarks = n_samples - - theta_values = [] - for prior in priors: - if prior[0] == "flat": - prior_min = prior[1] - prior_max = prior[2] - theta_values.append(prior_min + (prior_max - prior_min) * np.random.rand(n_benchmarks)) - - elif prior[0] == "gaussian": - prior_mean = prior[1] - prior_std = prior[2] - theta_values.append(np.random.normal(loc=prior_mean, scale=prior_std, size=n_benchmarks)) - - else: - raise ValueError("Unknown prior {}".format(prior)) - - theta_types = ["morphing"] * n_benchmarks - theta_values = np.array(theta_values).T - n_samples_per_theta = int(round(n_samples / n_benchmarks, 0)) - - logger.debug( - "Total n_samples: %s, n_benchmarks_phys: %s, n_samples_per_theta: %s", - n_samples, - n_benchmarks, - n_samples_per_theta, - ) - - else: - raise ValueError("Unknown theta {}".format(theta)) - - return theta_types, theta_values, n_samples_per_theta - - -def mdot(matrix, benchmark_information): - """ Calculates a product between a matrix with shape (a, n1) and a weight list with shape (?, n2) with n1 <= n2 """ - - n_benchmarks_matrix = matrix.shape[-1] - weights_benchmarks_T = benchmark_information.T - n_benchmarks_list = weights_benchmarks_T.shape[0] - n_smaller = min(n_benchmarks_matrix, n_benchmarks_list) - - if n_benchmarks_matrix == n_benchmarks_list: - return matrix.dot(weights_benchmarks_T) - - if n_benchmarks_matrix < n_benchmarks_list: - matrix = matrix.T - matrix = matrix[:n_smaller] - matrix = matrix.T - - return matrix.dot(weights_benchmarks_T[:n_smaller]) diff --git a/madminer/utils/histo.py b/madminer/utils/histo.py new file mode 100644 index 000000000..938052000 --- /dev/null +++ b/madminer/utils/histo.py @@ -0,0 +1,193 @@ +from __future__ import absolute_import, division, print_function, unicode_literals + +import numpy as np +import logging + +logger = logging.getLogger(__name__) + + +class Histo: + def __init__(self, n_bins_thetas, n_bins_x, separate_1d_histos=False): + self.n_bins_thetas = n_bins_thetas + self.n_bins_x = n_bins_x + self.separate_1d_x_histos = separate_1d_histos + + logger.debug("Initialized histogram with the following settings:") + logger.debug(" Bins per parameter: %s", self.n_bins_thetas) + logger.debug(" Bins per observable: %s", self.n_bins_x) + + # Not yet trained + self.n_parameters = None + self.n_observables = None + self.n_bins = None + self.edges = None + self.histos = None + + def _calculate_binning( + self, theta, x, observables=None, lower_cutoff_percentile=0.0, upper_cutoff_percentile=100.0 + ): + all_theta_x = np.hstack([theta, x]).T + + # Number of bins + n_samples = x.shape[0] + n_parameters = theta.shape[1] + n_all_observables = x.shape[1] + + # Observables to actually use + if observables is None: + observables = list(range(n_all_observables)) + + # Number of bins + all_n_bins_x = [1 for _ in range(n_all_observables)] + for i in observables: + all_n_bins_x[i] = self.n_bins_x + + if isinstance(self.n_bins_thetas, int): + all_n_bins_theta = [self.n_bins_thetas for _ in range(n_parameters)] + elif len(self.n_bins_thetas) == n_parameters: + all_n_bins_theta = self.n_bins_thetas + else: + raise RuntimeError( + "Inconsistent bin numbers for parameteers: {} vs {} parameters".format(self.n_bins_thetas, n_parameters) + ) + + all_n_bins = all_n_bins_theta + all_n_bins_x + + # Find edges based on percentiles + all_edges = [] + all_ranges = [] + + for i, (data, n_bins) in enumerate(zip(all_theta_x, all_n_bins)): + edges = np.percentile(data, np.linspace(lower_cutoff_percentile, upper_cutoff_percentile, n_bins + 1)) + range_ = (np.nanmin(data) - 0.01, np.nanmax(data) + 0.01) + edges[0], edges[-1] = range_ + + # Remove zero-width bins + widths = np.array(list(edges[1:] - edges[:-1]) + [1.0]) + edges = edges[widths > 1.0e-9] + + all_n_bins[i] = len(edges) - 1 + all_edges.append(edges) + all_ranges.append(range_) + + return all_n_bins, all_edges, all_ranges + + def fit(self, theta, x, fill_empty_bins=False): + + n_samples = x.shape[0] + self.n_parameters = theta.shape[1] + self.n_observables = x.shape[1] + assert theta.shape[0] == n_samples + + logger.debug("Filling histogram with settings:") + logger.debug(" Samples: %s", n_samples) + logger.debug(" Parameters: %s with means %s", self.n_parameters, np.mean(theta, axis=0)) + logger.debug(" Observables: %s with means %s", self.n_observables, np.mean(x, axis=0)) + logger.debug(" No empty bins: %s", fill_empty_bins) + + # Find bins + logger.debug("Calculating binning") + + self.n_bins = [] + self.edges = [] + ranges = [] + + if self.separate_1d_x_histos: + for observable in range(self.n_observables): + histo_n_bins, histo_edges, histo_ranges = self._calculate_binning(theta, x, [observable]) + + self.n_bins.append(histo_n_bins) + self.edges.append(histo_edges) + ranges.append(histo_ranges) + + else: + histo_n_bins, histo_edges, histo_ranges = self._calculate_binning(theta, x) + + self.n_bins.append(histo_n_bins) + self.edges.append(histo_edges) + ranges.append(histo_ranges) + + for h, (histo_n_bins, histo_edges, histo_ranges) in enumerate(zip(self.n_bins, self.edges, ranges)): + logger.debug("Histogram %s: bin edges", h + 1) + for i, (axis_bins, axis_edges, axis_range) in enumerate(zip(histo_n_bins, histo_edges, histo_ranges)): + if i < theta.shape[1]: + logger.debug(" theta %s: %s bins, range %s, edges %s", i + 1, axis_bins, axis_range, axis_edges) + else: + logger.debug( + " x %s: %s bins, range %s, edges %s", + i + 1 - theta.shape[1], + axis_bins, + axis_range, + axis_edges, + ) + + # Fill histograms + logger.debug("Filling histograms") + self.histos = [] + theta_x = np.hstack([theta, x]) + + for histo_edges, histo_ranges, histo_n_bins in zip(self.edges, ranges, self.n_bins): + histo, _ = np.histogramdd(theta_x, bins=histo_edges, range=histo_ranges, normed=False, weights=None) + + # Avoid empty bins + if fill_empty_bins: + histo[histo <= 1.0] = 1.0 + + # Calculate cell volumes + original_shape = tuple(histo_n_bins) + flat_shape = tuple([-1] + list(histo_n_bins[self.n_parameters :])) + + # Fix edges for bvolume calculation (to avoid larger volumes for more training data) + modified_histo_edges = [] + for i in range(x.shape[1]): + axis_edges = histo_edges[self.n_parameters + i] + axis_edges[0] = min(np.percentile(x[:, i], 5.0), axis_edges[1] - 0.01) + axis_edges[-1] = max(np.percentile(x[:, i], 95.0), axis_edges[-2] + 0.01) + modified_histo_edges.append(axis_edges) + + bin_widths = [axis_edges[1:] - axis_edges[:-1] for axis_edges in modified_histo_edges] + + volumes = np.ones(flat_shape[1:]) + for obs in range(self.n_observables): + # Broadcast bin widths to array with shape like volumes + bin_widths_broadcasted = np.ones(flat_shape[1:]) + for indices in np.ndindex(flat_shape[1:]): + bin_widths_broadcasted[indices] = bin_widths[obs][indices[obs]] + volumes[:] *= bin_widths_broadcasted + + # Normalize histograms (for each theta bin) + histo = histo.reshape(flat_shape) + + for i in range(histo.shape[0]): + histo[i] /= np.sum(histo[i]) + histo[i] /= volumes + + histo = histo.reshape(original_shape) + + # Avoid NaNs + histo[np.invert(np.isfinite(histo))] = 0.0 + + self.histos.append(histo) + + def log_likelihood(self, theta, x): + if len(theta.shape) == 1: + theta_ = np.broadcast_to(theta, (x.shape[0], theta.shape[0])) + else: + theta_ = theta + theta_x = np.hstack([theta_, x]) + + log_p = 0.0 + for histo, histo_edges, n_bins in zip(self.histos, self.edges, self.n_bins): + histo_indices = [] + + for j in range(theta_x.shape[1]): + indices = np.searchsorted(histo_edges[j], theta_x[:, j], side="right") - 1 + + indices[indices < 0] = 0 + indices[indices >= n_bins[j]] = n_bins[j] - 1 + + histo_indices.append(indices) + + log_p += np.log(histo[histo_indices]) + + return log_p diff --git a/madminer/utils/interfaces/delphes_root.py b/madminer/utils/interfaces/delphes_root.py index 325e67ff3..f8d15dfa8 100644 --- a/madminer/utils/interfaces/delphes_root.py +++ b/madminer/utils/interfaces/delphes_root.py @@ -247,7 +247,7 @@ def get_objects(ievent): def _get_n_events(tree): - es = tree.array("Particle.E") + es = tree.array("Event") n_events = len(es) return n_events diff --git a/madminer/utils/interfaces/lhe.py b/madminer/utils/interfaces/lhe.py index a6d610901..a474532a7 100644 --- a/madminer/utils/interfaces/lhe.py +++ b/madminer/utils/interfaces/lhe.py @@ -29,6 +29,8 @@ def parse_lhe_file( observables_defaults=None, cuts=None, cuts_default_pass=None, + efficiencies=None, + efficiencies_default_pass=None, benchmark_names=None, is_background=False, energy_resolutions=None, @@ -68,6 +70,12 @@ def parse_lhe_file( if cuts_default_pass is None: cuts_default_pass = {key: False for key in six.iterkeys(cuts)} + if efficiencies is None: + efficiencies = OrderedDict() + + if efficiencies_default_pass is None: + efficiencies_default_pass = {key: 1.0 for key in six.iterkeys(efficiencies)} + # Untar and open LHE file root, filename = _untar_and_parse_lhe_file(filename) @@ -126,6 +134,9 @@ def parse_lhe_file( pass_cuts = [0 for _ in cuts] fail_cuts = [0 for _ in cuts] + pass_efficiencies = [0 for _ in efficiencies] + fail_efficiencies = [0 for _ in efficiencies] + avg_efficiencies = [0 for _ in efficiencies] # Option one: XML parsing if parse_events_as_xml: @@ -150,7 +161,7 @@ def parse_lhe_file( if weight_names_all_events is None: weight_names_all_events = list(weights.keys()) - weights = list(weights.values()) + weights = np.array(list(weights.values())) # Apply smearing particles = _smear_particles( @@ -162,13 +173,14 @@ def parse_lhe_file( # Calculate observables observations = [] + pass_all_observation = True for obs_name, obs_definition in six.iteritems(observables): if isinstance(obs_definition, six.string_types): try: observations.append(eval(obs_definition, variables)) except (SyntaxError, NameError, TypeError, ZeroDivisionError, IndexError): if observables_required[obs_name]: - continue + pass_all_abservation = False default = observables_defaults[obs_name] if default is None: @@ -179,13 +191,16 @@ def parse_lhe_file( observations.append(obs_definition(particles)) except RuntimeError: if observables_required[obs_name]: - continue + pass_all_abservation = False default = observables_defaults[obs_name] if default is None: default = np.nan observations.append(default) + if not pass_all_observation: + continue + # Objects for cuts for obs_name, obs_value in zip(observables.keys(), observations): variables[obs_name] = obs_value @@ -211,6 +226,34 @@ def parse_lhe_file( if not pass_all_cuts: continue + # Apply efficiencies + pass_all_efficiencies = True + total_efficiency = 1.0 + for i_efficiency, (efficiency, default_pass) in enumerate(zip(efficiencies, efficiencies_default_pass)): + try: + efficiency_result = eval(efficiency, variables) + if efficiency_result > 0.0: + pass_efficiencies[i_efficiency] += 1 + total_efficiency *= efficiency_result + avg_efficiencies[i_efficiency] += efficiency_result + else: + fail_efficiencies[i_efficiency] += 1 + pass_all_efficiencies = False + + except (SyntaxError, NameError, TypeError, ZeroDivisionError, IndexError): + if default_pass > 0.0: + pass_efficiencies[i_efficiency] += 1 + total_efficiency *= default_pass + avg_efficiencies[i_efficiency] += default_pass + else: + fail_efficiencies[i_efficiency] += 1 + pass_all_efficiencies = False + + if pass_all_efficiencies: + weights *= total_efficiency + else: + continue + # Store results observations_all_events.append(observations) weights_all_events.append(weights) @@ -238,7 +281,7 @@ def parse_lhe_file( if weight_names_all_events is None: weight_names_all_events = list(weights.keys()) - weights = list(weights.values()) + weights = np.array(list(weights.values())) # Apply smearing particles = _smear_particles( @@ -250,13 +293,14 @@ def parse_lhe_file( # Calculate observables observations = [] + pass_all_observation = True for obs_name, obs_definition in six.iteritems(observables): if isinstance(obs_definition, six.string_types): try: observations.append(eval(obs_definition, variables)) except (SyntaxError, NameError, TypeError, ZeroDivisionError, IndexError): if observables_required[obs_name]: - continue + pass_all_observation = False default = observables_defaults[obs_name] if default is None: @@ -267,13 +311,16 @@ def parse_lhe_file( observations.append(obs_definition(particles)) except RuntimeError: if observables_required[obs_name]: - continue + pass_all_observation = False default = observables_defaults[obs_name] if default is None: default = np.nan observations.append(default) + if not pass_all_observation: + continue + # Objects for cuts for obs_name, obs_value in zip(observables.keys(), observations): variables[obs_name] = obs_value @@ -299,6 +346,34 @@ def parse_lhe_file( if not pass_all_cuts: continue + # Apply efficiencies + pass_all_efficiencies = True + total_efficiency = 1.0 + for i_efficiency, (efficiency, default_pass) in enumerate(zip(efficiencies, efficiencies_default_pass)): + try: + efficiency_result = eval(efficiency, variables) + if efficiency_result > 0.0: + pass_efficiencies[i_efficiency] += 1 + total_efficiency *= efficiency_result + avg_efficiencies[i_efficiency] += efficiency_result + else: + fail_efficiencies[i_efficiency] += 1 + pass_all_efficiencies = False + + except (SyntaxError, NameError, TypeError, ZeroDivisionError, IndexError): + if default_pass > 0.0: + pass_efficiencies[i_efficiency] += 1 + total_efficiency *= default_pass + avg_efficiencies[i_efficiency] += default_pass + else: + fail_efficiencies[i_efficiency] += 1 + pass_all_efficiencies = False + + if pass_all_efficiencies: + weights *= total_efficiency + else: + continue + # Store results observations_all_events.append(observations) weights_all_events.append(weights) @@ -306,9 +381,14 @@ def parse_lhe_file( # Check results for n_pass, n_fail, cut in zip(pass_cuts, fail_cuts, cuts): logger.debug(" %s / %s events pass cut %s", n_pass, n_pass + n_fail, cut) + for n_pass, n_fail, efficiency in zip(pass_efficiencies, fail_efficiencies, efficiencies): + logger.debug(" %s / %s events pass efficiency %s", n_pass, n_pass + n_fail, efficiency) + for n_eff, efficiency, n_pass, n_fail in zip(avg_efficiencies, efficiencies, pass_efficiencies, fail_efficiencies): + logger.debug(" average efficiency for %s is %s", efficiency, n_eff / (n_pass + n_fail)) + n_events_pass = len(observations_all_events) if len(cuts) > 0: - logger.info(" %s events pass all cuts", n_events_pass) + logger.info(" %s events pass all cuts/efficiencies", n_events_pass) if n_events_with_negative_weights > 0: logger.warning(" %s events contain negative weights", n_events_with_negative_weights) diff --git a/madminer/utils/interfaces/madminer_hdf5.py b/madminer/utils/interfaces/madminer_hdf5.py index 0f623f332..492e88751 100644 --- a/madminer/utils/interfaces/madminer_hdf5.py +++ b/madminer/utils/interfaces/madminer_hdf5.py @@ -243,6 +243,9 @@ def load_madminer_settings(filename, include_nuisance_benchmarks=False): def madminer_event_loader( filename, start=0, end=None, batch_size=100000, include_nuisance_parameters=True, benchmark_is_nuisance=None ): + if start is None: + start = 0 + # Nuisance parameter filtering if not include_nuisance_parameters: if benchmark_is_nuisance is None: diff --git a/madminer/utils/ml/eval.py b/madminer/utils/ml/eval.py index 6bc27e677..89d267e6d 100644 --- a/madminer/utils/ml/eval.py +++ b/madminer/utils/ml/eval.py @@ -5,7 +5,7 @@ import torch from torch import tensor -from madminer.utils.ml.models.ratio import ParameterizedRatioEstimator, DoublyParameterizedRatioEstimator +from madminer.utils.ml.models.ratio import DenseSingleParameterizedRatioModel, DenseDoublyParameterizedRatioModel logger = logging.getLogger(__name__) @@ -77,9 +77,9 @@ def evaluate_ratio_model( # Figure out method type if method_type is None: - if isinstance(model, ParameterizedRatioEstimator): + if isinstance(model, DenseSingleParameterizedRatioModel): method_type = "parameterized" - elif isinstance(model, DoublyParameterizedRatioEstimator): + elif isinstance(model, DenseDoublyParameterizedRatioModel): method_type = "doubly_parameterized" else: raise RuntimeError("Cannot infer method type automatically") @@ -111,7 +111,7 @@ def evaluate_ratio_model( if evaluate_score or return_grad_x: model.eval() - if method_type == "parameterized": + if method_type == "parameterized_ratio": if return_grad_x: s_hat, log_r_hat, t_hat0, x_gradients = model( theta0s, xs, return_grad_x=True, track_score=evaluate_score, create_gradient_graph=False @@ -120,7 +120,7 @@ def evaluate_ratio_model( s_hat, log_r_hat, t_hat0 = model(theta0s, xs, track_score=evaluate_score, create_gradient_graph=False) x_gradients = None t_hat1 = None - elif method_type == "doubly_parameterized": + elif method_type == "double_parameterized_ratio": if return_grad_x: s_hat, log_r_hat, t_hat0, t_hat1, x_gradients = model( theta0s, theta1s, xs, return_grad_x=True, track_score=evaluate_score, create_gradient_graph=False @@ -155,9 +155,9 @@ def evaluate_ratio_model( with torch.no_grad(): model.eval() - if method_type == "parameterized": + if method_type == "parameterized_ratio": s_hat, log_r_hat, _ = model(theta0s, xs, track_score=False, create_gradient_graph=False) - elif method_type == "doubly_parameterized": + elif method_type == "double_parameterized_ratio": s_hat, log_r_hat, _, _ = model(theta0s, theta1s, xs, track_score=False, create_gradient_graph=False) else: raise ValueError("Unknown method type %s", method_type) diff --git a/madminer/utils/ml/methods.py b/madminer/utils/ml/methods.py deleted file mode 100644 index 96cfce311..000000000 --- a/madminer/utils/ml/methods.py +++ /dev/null @@ -1,123 +0,0 @@ -from __future__ import absolute_import, division, print_function - -from collections import OrderedDict - -import madminer.utils.ml.losses -from madminer.utils.ml import losses -from madminer.utils.ml.trainer import SingleParameterizedRatioTrainer, DoubleParameterizedRatioTrainer -from madminer.utils.ml.trainer import FlowTrainer, LocalScoreTrainer - - -def get_method_type(method): - if method in ["carl", "rolr", "cascal", "rascal", "alice", "alices"]: - method_type = "parameterized" - elif method in ["carl2", "rolr2", "rascal2", "alice2", "alices2"]: - method_type = "doubly_parameterized" - elif method in ["sally", "sallino"]: - method_type = "local_score" - elif method in ["nde", "scandal"]: - method_type = "nde" - else: - raise RuntimeError("Unknown method {}".format(method)) - return method_type - - -def package_training_data(method, x, theta0, theta1, y, r_xz, t_xz0, t_xz1): - method_type = get_method_type(method) - data = OrderedDict() - if method_type == "parameterized": - data["x"] = x - data["theta"] = theta0 - data["y"] = y - if r_xz is not None: - data["r_xz"] = r_xz - if t_xz0 is not None: - data["t_xz"] = t_xz0 - elif method_type == "doubly_parameterized": - data["x"] = x - data["theta0"] = theta0 - data["theta1"] = theta1 - data["y"] = y - if r_xz is not None: - data["r_xz"] = r_xz - if t_xz0 is not None: - data["t_xz0"] = t_xz0 - if t_xz1 is not None: - data["t_xz1"] = t_xz1 - elif method_type == "local_score": - data["x"] = x - data["t_xz"] = t_xz0 - elif method_type == "nde": - data["x"] = x - data["theta"] = theta0 - if t_xz0 is not None: - data["t_xz"] = t_xz0 - return data - - -def get_trainer(method): - method_type = get_method_type(method) - if method_type == "parameterized": - return SingleParameterizedRatioTrainer - elif method_type == "doubly_parameterized": - return DoubleParameterizedRatioTrainer - elif method_type == "local_score": - return LocalScoreTrainer - elif method_type == "nde": - return FlowTrainer - else: - raise RuntimeError("Unknown method %s", method) - - -def get_loss(method, alpha): - if method in ["carl", "carl2"]: - loss_functions = [losses.ratio_xe] - loss_weights = [1.0] - loss_labels = ["xe"] - elif method in ["rolr", "rolr2"]: - loss_functions = [losses.ratio_mse] - loss_weights = [1.0] - loss_labels = ["mse_r"] - elif method == "cascal": - loss_functions = [losses.ratio_xe, losses.ratio_score_mse_num] - loss_weights = [1.0, alpha] - loss_labels = ["xe", "mse_score"] - elif method == "cascal2": - loss_functions = [losses.ratio_xe, losses.ratio_score_mse] - loss_weights = [1.0, alpha] - loss_labels = ["xe", "mse_score"] - elif method == "rascal": - loss_functions = [losses.ratio_mse, losses.ratio_score_mse_num] - loss_weights = [1.0, alpha] - loss_labels = ["mse_r", "mse_score"] - elif method == "rascal2": - loss_functions = [losses.ratio_mse, losses.ratio_score_mse] - loss_weights = [1.0, alpha] - loss_labels = ["mse_r", "mse_score"] - elif method in ["alice", "alice2"]: - loss_functions = [losses.ratio_augmented_xe] - loss_weights = [1.0] - loss_labels = ["improved_xe"] - elif method == "alices": - loss_functions = [losses.ratio_augmented_xe, losses.ratio_score_mse_num] - loss_weights = [1.0, alpha] - loss_labels = ["improved_xe", "mse_score"] - elif method == "alices2": - loss_functions = [losses.ratio_augmented_xe, losses.ratio_score_mse] - loss_weights = [1.0, alpha] - loss_labels = ["improved_xe", "mse_score"] - elif method in ["sally", "sallino"]: - loss_functions = [losses.local_score_mse] - loss_weights = [1.0] - loss_labels = ["mse_score"] - elif method == "nde": - loss_functions = [madminer.utils.ml.losses.flow_nll] - loss_weights = [1.0] - loss_labels = ["nll"] - elif method == "scandal": - loss_functions = [madminer.utils.ml.losses.flow_nll, madminer.utils.ml.losses.flow_score_mse] - loss_weights = [1.0, alpha] - loss_labels = ["nll", "mse_score"] - else: - raise NotImplementedError("Unknown method {}".format(method)) - return loss_functions, loss_labels, loss_weights diff --git a/madminer/utils/ml/models/ratio.py b/madminer/utils/ml/models/ratio.py index c77e146c5..e7a94e685 100644 --- a/madminer/utils/ml/models/ratio.py +++ b/madminer/utils/ml/models/ratio.py @@ -9,13 +9,13 @@ logger = logging.getLogger(__name__) -class ParameterizedRatioEstimator(nn.Module): +class DenseSingleParameterizedRatioModel(nn.Module): """ Module that implements agnostic parameterized likelihood estimators such as RASCAL or ALICES. Only the numerator of the ratio is parameterized. """ def __init__(self, n_observables, n_parameters, n_hidden, activation="tanh"): - super(ParameterizedRatioEstimator, self).__init__() + super(DenseSingleParameterizedRatioModel, self).__init__() # Save input self.n_hidden = n_hidden @@ -84,7 +84,7 @@ def forward(self, theta, x, track_score=True, return_grad_x=False, create_gradie return s_hat, log_r_hat, t_hat def to(self, *args, **kwargs): - self = super(ParameterizedRatioEstimator, self).to(*args, **kwargs) + self = super(DenseSingleParameterizedRatioModel, self).to(*args, **kwargs) for i, layer in enumerate(self.layers): self.layers[i] = layer.to(*args, **kwargs) @@ -92,13 +92,13 @@ def to(self, *args, **kwargs): return self -class DoublyParameterizedRatioEstimator(nn.Module): +class DenseDoublyParameterizedRatioModel(nn.Module): """ Module that implements agnostic parameterized likelihood estimators such as RASCAL or ALICES. Both numerator and denominator of the ratio are parameterized. """ def __init__(self, n_observables, n_parameters, n_hidden, activation="tanh"): - super(DoublyParameterizedRatioEstimator, self).__init__() + super(DenseDoublyParameterizedRatioModel, self).__init__() # Save input self.n_hidden = n_hidden @@ -189,7 +189,7 @@ def forward(self, theta0, theta1, x, track_score=True, return_grad_x=False, crea return s_hat, log_r_hat, t_hat0, t_hat1 def to(self, *args, **kwargs): - self = super(DoublyParameterizedRatioEstimator, self).to(*args, **kwargs) + self = super(DenseDoublyParameterizedRatioModel, self).to(*args, **kwargs) for i, layer in enumerate(self.layers): self.layers[i] = layer.to(*args, **kwargs) diff --git a/madminer/utils/ml/models/score.py b/madminer/utils/ml/models/score.py index 6aaa64381..f882db867 100644 --- a/madminer/utils/ml/models/score.py +++ b/madminer/utils/ml/models/score.py @@ -9,13 +9,13 @@ logger = logging.getLogger(__name__) -class LocalScoreEstimator(nn.Module): +class DenseLocalScoreModel(nn.Module): """Module that implements local score estimators for methods like SALLY and SALLINO, or the calculation of Fisher information matrices.""" def __init__(self, n_observables, n_parameters, n_hidden, activation="tanh"): - super(LocalScoreEstimator, self).__init__() + super(DenseLocalScoreModel, self).__init__() # Save input self.n_hidden = n_hidden @@ -57,7 +57,7 @@ def forward(self, x, return_grad_x=False): return t_hat def to(self, *args, **kwargs): - self = super(LocalScoreEstimator, self).to(*args, **kwargs) + self = super(DenseLocalScoreModel, self).to(*args, **kwargs) for i, layer in enumerate(self.layers): self.layers[i] = layer.to(*args, **kwargs) diff --git a/madminer/utils/ml/trainer.py b/madminer/utils/ml/trainer.py index 6f505671d..78e986559 100644 --- a/madminer/utils/ml/trainer.py +++ b/madminer/utils/ml/trainer.py @@ -17,6 +17,10 @@ class EarlyStoppingException(Exception): pass +class NanException(Exception): + pass + + class Trainer(object): """ Trainer class. Any subclass has to implement the forward_pass() function. """ @@ -100,11 +104,15 @@ def train( self.set_lr(opt, lr) logger.debug("Learning rate: %s", lr) - loss_train, loss_val, loss_contributions_train, loss_contributions_val = self.epoch( - i_epoch, data_labels, train_loader, val_loader, opt, loss_functions, loss_weights, clip_gradient - ) - losses_train.append(loss_train) - losses_val.append(loss_val) + try: + loss_train, loss_val, loss_contributions_train, loss_contributions_val = self.epoch( + i_epoch, data_labels, train_loader, val_loader, opt, loss_functions, loss_weights, clip_gradient + ) + losses_train.append(loss_train) + losses_val.append(loss_val) + except NanException: + logger.info("Ending training during epoch %s because NaNs appeared", i_epoch + 1) + break if early_stopping: try: @@ -112,7 +120,7 @@ def train( best_loss, best_model, best_epoch, loss_val, i_epoch, early_stopping_patience ) except EarlyStoppingException: - logger.debug("Early stopping: ending training after %s epochs", i_epoch + 1) + logger.info("Early stopping: ending training after %s epochs", i_epoch + 1) break verbose_epoch = (i_epoch + 1) % n_epochs_verbose == 0 @@ -126,7 +134,7 @@ def train( verbose=verbose_epoch, ) - if early_stopping: + if early_stopping and len(losses_val) > 0: self.wrap_up_early_stopping(best_model, losses_val[-1], best_loss, best_epoch) logger.debug("Training finished") @@ -185,6 +193,8 @@ def make_dataloaders(self, dataset, validation_split, batch_size): @staticmethod def calculate_lr(i_epoch, n_epochs, initial_lr, final_lr): + if n_epochs == 1: + return initial_lr return initial_lr * (final_lr / initial_lr) ** float(i_epoch / (n_epochs - 1.0)) @staticmethod @@ -347,6 +357,15 @@ def wrap_up_early_stopping(self, best_model, currrent_loss, best_loss, best_epoc else: logger.info("Early stopping did not improve performance") + @staticmethod + def _check_for_nans(label, *tensors): + for tensor in tensors: + if tensor is None: + continue + if torch.isnan(tensor).any(): + logger.warning("%s contains NaNs, aborting training! Data:\n%s", label, tensor) + raise NanException + class SingleParameterizedRatioTrainer(Trainer): def __init__(self, model, run_on_gpu=True, double_precision=False): @@ -392,10 +411,15 @@ def forward_pass(self, batch_data, loss_functions): t_xz = batch_data["t_xz"].to(self.device, self.dtype) except KeyError: t_xz = None + self._check_for_nans("Training data", theta, x, y) + self._check_for_nans("Augmented training data", r_xz, t_xz) s_hat, log_r_hat, t_hat = self.model(theta, x, track_score=self.calculate_model_score, return_grad_x=False) + self._check_for_nans("Model output", s_hat, log_r_hat, t_hat) losses = [loss_function(s_hat, log_r_hat, t_hat, None, y, r_xz, t_xz, None) for loss_function in loss_functions] + self._check_for_nans("Loss", *losses) + return losses @@ -448,14 +472,19 @@ def forward_pass(self, batch_data, loss_functions): t_xz1 = batch_data["t_xz1"].to(self.device, self.dtype) except KeyError: t_xz1 = None + self._check_for_nans("Training data", theta0, theta1, x, y) + self._check_for_nans("Augmented training data", r_xz, t_xz0, t_xz1) s_hat, log_r_hat, t_hat0, t_hat1 = self.model( theta0, theta1, x, track_score=self.calculate_model_score, return_grad_x=False ) + self._check_for_nans("Model output", s_hat, log_r_hat, t_hat0, t_hat1) losses = [ loss_function(s_hat, log_r_hat, t_hat0, t_hat1, y, r_xz, t_xz0, t_xz1) for loss_function in loss_functions ] + self._check_for_nans("Loss", *losses) + return losses @@ -472,10 +501,15 @@ def check_data(self, data): def forward_pass(self, batch_data, loss_functions): x = batch_data["x"].to(self.device, self.dtype) t_xz = batch_data["t_xz"].to(self.device, self.dtype) + self._check_for_nans("Training data", x) + self._check_for_nans("Augmented training data", t_xz) t_hat = self.model(x) + self._check_for_nans("Model output", t_hat) losses = [loss_function(t_hat, t_xz) for loss_function in loss_functions] + self._check_for_nans("Loss", *losses) + return losses @@ -518,12 +552,17 @@ def forward_pass(self, batch_data, loss_functions): t_xz = batch_data["t_xz"].to(self.device, self.dtype) except KeyError: t_xz = None + self._check_for_nans("Training data", theta, x) + self._check_for_nans("Augmented training data", t_xz) if self.calculate_model_score: _, log_likelihood, t_hat = self.model.log_likelihood_and_score(theta, x) else: _, log_likelihood = self.model.log_likelihood(theta, x) t_hat = None + self._check_for_nans("Model output", log_likelihood, t_hat) losses = [loss_function(log_likelihood, t_hat, t_xz) for loss_function in loss_functions] + self._check_for_nans("Loss", *losses) + return losses diff --git a/madminer/utils/ml/utils.py b/madminer/utils/ml/utils.py index 5ee948fbd..606c4652d 100644 --- a/madminer/utils/ml/utils.py +++ b/madminer/utils/ml/utils.py @@ -3,6 +3,10 @@ import numpy as np import torch import logging +from torch import optim + +import madminer.utils +from madminer.utils.ml import losses logger = logging.getLogger(__name__) @@ -78,3 +82,73 @@ def check_required_data(method, r_xz, t_xz0, t_xz1, theta0, theta1, x, y): if method in ["rascal2", "alices2"] and t_xz1 is None: data_is_there = False return data_is_there + + +def get_optimizer(optimizer, nesterov_momentum): + opt_kwargs = None + if optimizer == "adam": + opt = optim.Adam + elif optimizer == "amsgrad": + opt = optim.Adam + opt_kwargs = {"amsgrad": True} + elif optimizer == "sgd": + opt = optim.SGD + if nesterov_momentum is not None: + opt_kwargs = {"momentum": nesterov_momentum} + else: + raise ValueError("Unknown optimizer {}".format(optimizer)) + return opt, opt_kwargs + + +def get_loss(method, alpha): + if method in ["carl", "carl2"]: + loss_functions = [losses.ratio_xe] + loss_weights = [1.0] + loss_labels = ["xe"] + elif method in ["rolr", "rolr2"]: + loss_functions = [losses.ratio_mse] + loss_weights = [1.0] + loss_labels = ["mse_r"] + elif method == "cascal": + loss_functions = [losses.ratio_xe, losses.ratio_score_mse_num] + loss_weights = [1.0, alpha] + loss_labels = ["xe", "mse_score"] + elif method == "cascal2": + loss_functions = [losses.ratio_xe, losses.ratio_score_mse] + loss_weights = [1.0, alpha] + loss_labels = ["xe", "mse_score"] + elif method == "rascal": + loss_functions = [losses.ratio_mse, losses.ratio_score_mse_num] + loss_weights = [1.0, alpha] + loss_labels = ["mse_r", "mse_score"] + elif method == "rascal2": + loss_functions = [losses.ratio_mse, losses.ratio_score_mse] + loss_weights = [1.0, alpha] + loss_labels = ["mse_r", "mse_score"] + elif method in ["alice", "alice2"]: + loss_functions = [losses.ratio_augmented_xe] + loss_weights = [1.0] + loss_labels = ["improved_xe"] + elif method == "alices": + loss_functions = [losses.ratio_augmented_xe, losses.ratio_score_mse_num] + loss_weights = [1.0, alpha] + loss_labels = ["improved_xe", "mse_score"] + elif method == "alices2": + loss_functions = [losses.ratio_augmented_xe, losses.ratio_score_mse] + loss_weights = [1.0, alpha] + loss_labels = ["improved_xe", "mse_score"] + elif method in ["sally", "sallino"]: + loss_functions = [losses.local_score_mse] + loss_weights = [1.0] + loss_labels = ["mse_score"] + elif method == "nde": + loss_functions = [madminer.utils.ml.losses.flow_nll] + loss_weights = [1.0] + loss_labels = ["nll"] + elif method == "scandal": + loss_functions = [madminer.utils.ml.losses.flow_nll, madminer.utils.ml.losses.flow_score_mse] + loss_weights = [1.0, alpha] + loss_labels = ["nll", "mse_score"] + else: + raise NotImplementedError("Unknown method {}".format(method)) + return loss_functions, loss_labels, loss_weights diff --git a/madminer/morphing.py b/madminer/utils/morphing.py similarity index 88% rename from madminer/morphing.py rename to madminer/utils/morphing.py index b2b38688b..1d3c70bd0 100644 --- a/madminer/morphing.py +++ b/madminer/utils/morphing.py @@ -1,6 +1,6 @@ from __future__ import absolute_import, division, print_function, unicode_literals -import six +import six import logging import numpy as np from collections import OrderedDict @@ -11,14 +11,14 @@ logger = logging.getLogger(__name__) -class Morpher: +class PhysicsMorpher: """ Morphing functionality for theory parameters. Morphing is a technique that allows MadMax to infer the full probability distribution `p(x_i | theta)` for each simulated event `x_i` and any `theta`, not just the benchmarks. For a typical MadMiner application, it is not necessary to use the morphing classes directly. The other MadMiner classes use the morphing functions "under the hood" when needed. Only for an isolated study of the morphing setup - (e.g. to optimize the morphing basis), the Morpher class itself may be of interest. + (e.g. to optimize the morphing basis), the PhysicsMorpher class itself may be of interest. A typical morphing basis setup involves the following steps: @@ -360,7 +360,8 @@ def calculate_morphing_matrix(self, basis=None): if basis is None: raise RuntimeError( - "No basis defined or given. Use Morpher.set_basis(), Morpher.optimize_basis(), or the " "basis keyword." + "No basis defined or given. Use PhysicsMorpher.set_basis(), PhysicsMorpher.optimize_basis(), or the " + "basis keyword." ) n_benchmarks = len(basis) @@ -437,7 +438,8 @@ def calculate_morphing_weights(self, theta, basis=None, morphing_matrix=None): if basis is None: raise RuntimeError( - "No basis defined or given. Use Morpher.set_basis(), Morpher.optimize_basis(), or the " "basis keyword." + "No basis defined or given. Use PhysicsMorpher.set_basis(), PhysicsMorpher.optimize_basis(), or the " + "basis keyword." ) if morphing_matrix is None: @@ -497,7 +499,8 @@ def calculate_morphing_weight_gradient(self, theta, basis=None, morphing_matrix= if basis is None: raise RuntimeError( - "No basis defined or given. Use Morpher.set_basis(), Morpher.optimize_basis(), or the " "basis keyword." + "No basis defined or given. Use PhysicsMorpher.set_basis(), PhysicsMorpher.optimize_basis(), or the " + "basis keyword." ) if morphing_matrix is None: @@ -578,7 +581,8 @@ def evaluate_morphing(self, basis=None, morphing_matrix=None, n_test_thetas=100, if basis is None: raise RuntimeError( - "No basis defined or given. Use Morpher.set_basis(), Morpher.optimize_basis(), or the " "basis keyword." + "No basis defined or given. Use PhysicsMorpher.set_basis(), PhysicsMorpher.optimize_basis(), or the " + "basis keyword." ) if morphing_matrix is None: @@ -760,11 +764,82 @@ def calculate_nuisance_factors(self, nuisance_parameters, benchmark_weights): """ + if nuisance_parameters is None: + nuisance_parameters = np.zeros(self.n_nuisance_parameters) + a = self.calculate_a(benchmark_weights) # Shape (n_nuisance_parameters, n_events) b = self.calculate_b(benchmark_weights) # Shape (n_nuisance_parameters, n_events) exponent = np.sum(a * nuisance_parameters[:, np.newaxis] + b * nuisance_parameters[:, np.newaxis] ** 2, axis=0) - nuisance_factors = np.exp(exponent) return nuisance_factors + + def calculate_log_nuisance_factor_gradients(self, nuisance_parameters, benchmark_weights): + """ + Calculates the gradient of the log of the nuisance factors with respect to the nuisance parameters. + + Parameters + ---------- + nuisance_parameters : ndarray + Values of the nuisance parameters `nu`, with shape `(n_nuisance_parameters,)`. + + benchmark_weights : ndarray + Event weights `dsigma(x | theta_i, nu_i)` with shape `(n_events, n_benchmarks)`. The benchmarks are expected + to be sorted in the same order as the keyword benchmark_names used during initialization, and the + nuisance benchmarks are expected to be rescaled to have the same physics parameters theta as the + reference_benchmark given during initialization. + + Returns + ------- + log_nuisance_factor_gradients : ndarray + Log nuisance factor gradients `grad_nu log (dsigma(x | theta, nu) / dsigma(x | theta, 0))` with shape + `(n_parameters, n_events)`. + + """ + + if nuisance_parameters is None: + nuisance_parameters = np.zeros(self.n_nuisance_parameters) + + a = self.calculate_a(benchmark_weights) # Shape (n_nuisance_parameters, n_events) + b = self.calculate_b(benchmark_weights) # Shape (n_nuisance_parameters, n_events) + + log_gradients = a + 2.0 * b * nuisance_parameters[:, np.newaxis] + + return log_gradients + + def calculate_nuisance_factor_gradients(self, nuisance_parameters, benchmark_weights): + """ + Calculates the gradient of the nuisance factors with respect to the nuisance parameters. + + Parameters + ---------- + nuisance_parameters : ndarray + Values of the nuisance parameters `nu`, with shape `(n_nuisance_parameters,)`. + + benchmark_weights : ndarray + Event weights `dsigma(x | theta_i, nu_i)` with shape `(n_events, n_benchmarks)`. The benchmarks are expected + to be sorted in the same order as the keyword benchmark_names used during initialization, and the + nuisance benchmarks are expected to be rescaled to have the same physics parameters theta as the + reference_benchmark given during initialization. + + Returns + ------- + nuisance_factor_gradients : ndarray + Nuisance factor gradients `grad_nu (dsigma(x | theta, nu) / dsigma(x | theta, 0))` with shape + `(n_parameters, n_events)`. + + """ + + if nuisance_parameters is None: + nuisance_parameters = np.zeros(self.n_nuisance_parameters) + + a = self.calculate_a(benchmark_weights) # Shape (n_nuisance_parameters, n_events) + b = self.calculate_b(benchmark_weights) # Shape (n_nuisance_parameters, n_events) + + exponent = np.sum(a * nuisance_parameters[:, np.newaxis] + b * nuisance_parameters[:, np.newaxis] ** 2, axis=0) + nuisance_factors = np.exp(exponent) + log_gradients = a + 2.0 * b * nuisance_parameters[:, np.newaxis] + gradients = log_gradients * nuisance_factors[np.newaxis, :] + + return gradients diff --git a/madminer/utils/various.py b/madminer/utils/various.py index e436336f9..23f48c0ce 100644 --- a/madminer/utils/various.py +++ b/madminer/utils/various.py @@ -100,21 +100,20 @@ def shuffle(*arrays): def restrict_samplesize(n, *arrays): restricted_arrays = [] - for i, a in enumerate(arrays): if a is None: restricted_arrays.append(None) continue - restricted_arrays.append(a[:n]) return restricted_arrays -def balance_thetas(theta_sets_types, theta_sets_values): +def balance_thetas(theta_sets_types, theta_sets_values, n_sets=None): """Repeats theta values such that all thetas lists have the same length """ - n_sets = max([len(thetas) for thetas in theta_sets_types]) + if n_sets is None: + n_sets = max([len(thetas) for thetas in theta_sets_types]) for i, (types, values) in enumerate(zip(theta_sets_types, theta_sets_values)): assert len(types) == len(values) @@ -142,12 +141,14 @@ def load_and_check(filename, warning_threshold=1.0e9): if filename is None: return None - data = np.load(filename) + if not isinstance(filename, six.string_types): + data = filename + else: + data = np.load(filename) n_nans = np.sum(np.isnan(data)) n_infs = np.sum(np.isinf(data)) n_finite = np.sum(np.isfinite(data)) - if n_nans + n_infs > 0: logger.warning( "Warning: file %s contains %s NaNs and %s Infs, compared to %s finite numbers!", @@ -159,10 +160,12 @@ def load_and_check(filename, warning_threshold=1.0e9): smallest = np.nanmin(data) largest = np.nanmax(data) - if np.abs(smallest) > warning_threshold or np.abs(largest) > warning_threshold: logger.warning("Warning: file %s has some large numbers, rangin from %s to %s", filename, smallest, largest) + if len(data.shape) == 1: + data = data.reshape(-1, 1) + return data @@ -264,3 +267,48 @@ def weighted_quantile(values, quantiles, sample_weight=None, values_sorted=False def approx_equal(a, b, epsilon=1.0e-6): return abs(a - b) < epsilon + + +def separate_information_blocks(fisher_information, parameters_of_interest): + # Find indices + n_parameters = len(fisher_information) + n_poi = len(parameters_of_interest) + + poi_checked = [] + nuisance_params = [] + + for i in range(n_parameters): + if i in parameters_of_interest: + poi_checked.append(i) + else: + nuisance_params.append(i) + + assert n_poi == len(poi_checked), "Inconsistent input" + + # Separate Fisher information parts + information_phys = fisher_information[parameters_of_interest, :][:, parameters_of_interest] + information_mix = fisher_information[nuisance_params, :][:, parameters_of_interest] + information_nuisance = fisher_information[nuisance_params, :][:, nuisance_params] + + return nuisance_params, information_phys, information_mix, information_nuisance + + +def mdot(matrix, benchmark_information): + """ + Calculates a product between a matrix / matrices with shape (n1) or (a, n1) and a weight list with shape (b, n2) + or (n2,), where n1 and n2 do not have to be the same + """ + + n1 = matrix.shape[-1] + weights_t = benchmark_information.T + n2 = weights_t.shape[0] + n_smaller = min(n1, n2) + + if n1 > n2: + matrix = matrix.T + matrix = matrix[:n_smaller] + matrix = matrix.T + elif n2 > n1: + weights_t = weights_t[:n_smaller] + + return matrix.dot(weights_t) diff --git a/setup.py b/setup.py index e744f119c..4fda420b9 100644 --- a/setup.py +++ b/setup.py @@ -20,7 +20,7 @@ EMAIL = 'johann.brehmer@nyu.edu' AUTHOR = 'Johann Brehmer, Felix Kling, Irina Espejo, Kyle Cranmer' REQUIRES_PYTHON = '>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4' -VERSION = '0.2.8' +VERSION = '0.3.0' # What packages are required for this module to be executed? REQUIRED = [ diff --git a/tests/test_imports.py b/tests/test_imports.py index 972157e24..1d60b3ca2 100644 --- a/tests/test_imports.py +++ b/tests/test_imports.py @@ -1,13 +1,2 @@ -from madminer.core import MadMiner -from madminer.delphes import DelphesProcessor -from madminer.lhe import LHEProcessor -from madminer.ml import EnsembleForge, MLForge -from madminer.morphing import Morpher, NuisanceMorpher -from madminer.plotting import plot_2d_morphing_basis, plot_distribution_of_information, plot_distributions -from madminer.plotting import plot_fisher_information_contours_2d, plot_fisherinfo_barplot -from madminer.plotting import plot_nd_morphing_basis_scatter, plot_2d_morphing_basis -from madminer.sampling import SampleAugmenter - - def test_imports(): assert True diff --git a/tests/test_nuisance.py b/tests/test_nuisance.py index a8208d005..c3127e09a 100644 --- a/tests/test_nuisance.py +++ b/tests/test_nuisance.py @@ -5,7 +5,7 @@ from collections import OrderedDict from madminer.core import MadMiner -from madminer.lhe import LHEProcessor +from madminer.lhe import LHEReader from madminer.fisherinformation import FisherInformation, profile_information @@ -25,7 +25,7 @@ def theta_limit_madminer(xsec=0.001, lumi=1000000.0, effect_phys=0.1, effect_sys miner.save(".data.h5") # Set up observations - proc = LHEProcessor(".data.h5") + proc = LHEReader(".data.h5") proc.add_observable("x", "no one cares") proc.reference_benchmark = "benchmark_0" proc.nuisance_parameters = OrderedDict() diff --git a/tests/test_toy_workflow.py b/tests/test_toy_workflow.py index 32ce4b499..e3a4b46dc 100644 --- a/tests/test_toy_workflow.py +++ b/tests/test_toy_workflow.py @@ -1,11 +1,10 @@ from __future__ import absolute_import, division, print_function, unicode_literals import os -import logging import numpy as np from scipy.stats import norm -from madminer.ml import MLForge +from madminer.ml import ParameterizedRatioEstimator if not os.path.exists("tests/data"): os.makedirs("tests/data") @@ -77,18 +76,16 @@ def run_test(): np.save("tests/data/t_xz_train.npy", t_xz_train) # Train model - forge = MLForge() - - forge.train( + estimator = ParameterizedRatioEstimator(n_hidden=(20, 20)) + estimator.train( method="alices", - x_filename="tests/data/x_train.npy", - y_filename="tests/data/y_train.npy", - theta0_filename="tests/data/theta0_train.npy", - r_xz_filename="tests/data/r_xz_train.npy", - t_xz0_filename="tests/data/t_xz_train.npy", + x="tests/data/x_train.npy", + y="tests/data/y_train.npy", + theta="tests/data/theta0_train.npy", + r_xz="tests/data/r_xz_train.npy", + t_xz="tests/data/t_xz_train.npy", alpha=0.1, n_epochs=10, - n_hidden=(20, 20), validation_split=None, batch_size=256, ) @@ -112,8 +109,8 @@ def run_test(): log_r_test_true = np.array(log_r_test_true) # Evaluation - log_r_tests_alices, _, _ = forge.evaluate( - theta0_filename="tests/data/theta_grid.npy", x="tests/data/x_test.npy", evaluate_score=False + log_r_tests_alices, _ = estimator.evaluate( + theta="tests/data/theta_grid.npy", x="tests/data/x_test.npy", evaluate_score=False ) # Calculate error