From 4d99beea0a6bd7400fc03d357906caeb9f304f64 Mon Sep 17 00:00:00 2001 From: Morten Hjorth-Jensen Date: Thu, 9 Nov 2023 08:15:45 +0100 Subject: [PATCH] Update week45.ipynb --- doc/pub/week45/ipynb/week45.ipynb | 1313 ++++++++++++++++++++++++----- 1 file changed, 1079 insertions(+), 234 deletions(-) diff --git a/doc/pub/week45/ipynb/week45.ipynb b/doc/pub/week45/ipynb/week45.ipynb index f3cbde629..a85902747 100644 --- a/doc/pub/week45/ipynb/week45.ipynb +++ b/doc/pub/week45/ipynb/week45.ipynb @@ -3,9 +3,7 @@ { "cell_type": "markdown", "id": "7e9869f2", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "\n", @@ -15,9 +13,7 @@ { "cell_type": "markdown", "id": "fca263d7", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "# Week 45, Recurrent Neural Networks\n", "**Morten Hjorth-Jensen**, Department of Physics, University of Oslo and Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University\n", @@ -28,9 +24,7 @@ { "cell_type": "markdown", "id": "8c3d9fea", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Plan for week 45\n", "\n", @@ -70,9 +64,7 @@ { "cell_type": "markdown", "id": "d0107e8f", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Material for the lab sessions, additional ways to present classification results and other practicalities" ] @@ -80,9 +72,7 @@ { "cell_type": "markdown", "id": "44ed2bb7", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Searching for Optimal Regularization Parameters $\\lambda$\n", "\n", @@ -99,10 +89,7 @@ "cell_type": "code", "execution_count": 1, "id": "7d202a1c", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", @@ -156,9 +143,7 @@ { "cell_type": "markdown", "id": "0fcc974f", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Here we have performed a rather data greedy calculation as function of the regularization parameter $\\lambda$. There is no resampling here. The latter can easily be added by employing the function **RidgeCV** instead of just calling the **Ridge** function. For **RidgeCV** we need to pass the array of $\\lambda$ values.\n", "By inspecting the figure we can in turn determine which is the optimal regularization parameter.\n", @@ -168,9 +153,7 @@ { "cell_type": "markdown", "id": "693475c8", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Grid Search\n", "\n", @@ -183,10 +166,7 @@ "cell_type": "code", "execution_count": 2, "id": "cdd8cf73", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -236,9 +216,7 @@ { "cell_type": "markdown", "id": "51ef3976", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "By default the grid search function includes cross validation with\n", "five folds. The [Scikit-Learn\n", @@ -251,9 +229,7 @@ { "cell_type": "markdown", "id": "033bda9d", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Randomized Grid Search\n", "\n", @@ -271,10 +247,7 @@ "cell_type": "code", "execution_count": 3, "id": "0a320c52", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -325,9 +298,7 @@ { "cell_type": "markdown", "id": "bcd8ea70", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Wisconsin Cancer Data\n", "\n", @@ -340,10 +311,7 @@ "cell_type": "code", "execution_count": 4, "id": "6fe70002", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -367,9 +335,7 @@ { "cell_type": "markdown", "id": "c4440f93", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Using the correlation matrix\n", "\n", @@ -381,10 +347,7 @@ "cell_type": "code", "execution_count": 5, "id": "96a74e80", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -426,9 +389,7 @@ { "cell_type": "markdown", "id": "98525677", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Discussing the correlation data\n", "\n", @@ -451,10 +412,7 @@ "cell_type": "code", "execution_count": 6, "id": "d00d3339", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "cancerpd = pd.DataFrame(cancer.data, columns=cancer.feature_names)" @@ -463,9 +421,7 @@ { "cell_type": "markdown", "id": "39d74647", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "and then" ] @@ -474,10 +430,7 @@ "cell_type": "code", "execution_count": 7, "id": "382459a0", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "correlation_matrix = cancerpd.corr().round(1)" @@ -486,9 +439,7 @@ { "cell_type": "markdown", "id": "06da1caf", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "Diagonalizing this matrix we can in turn say something about which\n", "features are of relevance and which are not. This leads us to\n", @@ -499,9 +450,7 @@ { "cell_type": "markdown", "id": "2d846128", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Other ways of presenting a classification problem\n", "\n", @@ -532,9 +481,7 @@ { "cell_type": "markdown", "id": "23991e3b", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Combinations of classification results\n", "\n", @@ -546,9 +493,7 @@ { "cell_type": "markdown", "id": "4581b004", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "{\\displaystyle \\mathrm {TPR} ={\\frac {\\mathrm {TP} }{\\mathrm {P} }}={\\frac {\\mathrm {TP} }{\\mathrm {TP} +\\mathrm {FN} }}=1-\\mathrm {FNR} }\n", @@ -558,9 +503,7 @@ { "cell_type": "markdown", "id": "855fc1d5", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "The $TPR$ defines how many correct positive results occur among all positive samples available during the test\n", "\n", @@ -570,9 +513,7 @@ { "cell_type": "markdown", "id": "7b676376", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "{\\displaystyle \\mathrm {FNR} ={\\frac {\\mathrm {FN} }{\\mathrm {P} }}={\\frac {\\mathrm {FN} }{\\mathrm {FN} +\\mathrm {TP} }} }\n", @@ -582,9 +523,7 @@ { "cell_type": "markdown", "id": "64e4f58f", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "**Specificity, selectivity or true negative rate $TNR$. It is the probability of a negative test result, conditioned on the individual truly being negative.**" ] @@ -592,9 +531,7 @@ { "cell_type": "markdown", "id": "6bef46ee", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "{\\displaystyle \\mathrm {TNR} ={\\frac {\\mathrm {TN} }{\\mathrm {N} }}={\\frac {\\mathrm {TN} }{\\mathrm {TN} +\\mathrm {FP} }}=1-\\mathrm {FPR} }\n", @@ -604,9 +541,7 @@ { "cell_type": "markdown", "id": "ed7cfd1e", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "with the fall-out false positive rate" ] @@ -614,9 +549,7 @@ { "cell_type": "markdown", "id": "307589a6", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "{\\displaystyle \\mathrm {FPR} ={\\frac {\\mathrm {FP} }{\\mathrm {N} }}={\\frac {\\mathrm {FP} }{\\mathrm {FP} +\\mathrm {TN} }}=1-\\mathrm {TNR} }\n", @@ -626,9 +559,7 @@ { "cell_type": "markdown", "id": "24f17f38", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "The $FPR$ defines how many incorrect positive results occur among\n", "all negative samples available during the test." @@ -637,9 +568,7 @@ { "cell_type": "markdown", "id": "e825c026", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Positive and negative prediction values\n", "\n", @@ -656,9 +585,7 @@ { "cell_type": "markdown", "id": "6dcb34a4", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "{\\displaystyle \\mathrm {PPV} ={\\frac {\\mathrm {TP} }{\\mathrm {TP} +\\mathrm {FP} }}=1-\\mathrm {FDR} }\n", @@ -668,9 +595,7 @@ { "cell_type": "markdown", "id": "a975cae8", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "**Negative predictive value $NPV$.**" ] @@ -678,9 +603,7 @@ { "cell_type": "markdown", "id": "d4971baf", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "{\\displaystyle \\mathrm {NPV} ={\\frac {\\mathrm {TN} }{\\mathrm {TN} +\\mathrm {FN} }}=1-\\mathrm {FOR} }\n", @@ -690,9 +613,7 @@ { "cell_type": "markdown", "id": "a4bd001d", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Other quantities\n", "\n", @@ -702,9 +623,7 @@ { "cell_type": "markdown", "id": "a8b1f114", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "{\\displaystyle \\mathrm {FDR} ={\\frac {\\mathrm {FP} }{\\mathrm {FP} +\\mathrm {TP} }}=1-\\mathrm {PPV} }\n", @@ -714,9 +633,7 @@ { "cell_type": "markdown", "id": "959cdbff", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "**False omission rate $FOR$.**" ] @@ -724,9 +641,7 @@ { "cell_type": "markdown", "id": "59ee7f47", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "{\\displaystyle \\mathrm {FOR} ={\\frac {\\mathrm {FN} }{\\mathrm {FN} +\\mathrm {TN} }}=1-\\mathrm {NPV} }\n", @@ -736,9 +651,7 @@ { "cell_type": "markdown", "id": "5cdba722", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## $F_1$ score\n", "\n", @@ -764,9 +677,7 @@ { "cell_type": "markdown", "id": "35390ed4", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "$$\n", "{\\displaystyle \\mathrm {F} _{1}=2\\times {\\frac {\\mathrm {PPV} \\times \\mathrm {TPR} }{\\mathrm {PPV} +\\mathrm {TPR} }}={\\frac {2\\mathrm {TP} }{2\\mathrm {TP} +\\mathrm {FP} +\\mathrm {FN} }}}\n", @@ -776,9 +687,7 @@ { "cell_type": "markdown", "id": "b1651ea3", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## ROC curve\n", "\n", @@ -801,9 +710,7 @@ { "cell_type": "markdown", "id": "1bfac852", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Cumulative gain curve\n", "\n", @@ -819,9 +726,7 @@ { "cell_type": "markdown", "id": "f655bb24", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Other measures in classification studies: Cancer Data again" ] @@ -830,10 +735,7 @@ "cell_type": "code", "execution_count": 8, "id": "31f4ee21", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -873,9 +775,7 @@ { "cell_type": "markdown", "id": "098bfaec", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Material for Lecture Thursday November 9" ] @@ -883,9 +783,7 @@ { "cell_type": "markdown", "id": "55cc0e20", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Recurrent neural networks (RNNs): Overarching view\n", "\n", @@ -910,22 +808,250 @@ { "cell_type": "markdown", "id": "8860da9c", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## A simple example" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 2, "id": "7252c0b8", - "metadata": { - "collapsed": false, - "editable": true - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_1\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " simple_rnn_1 (SimpleRNN) (None, 32) 1184 \n", + " \n", + " dense_2 (Dense) (None, 8) 264 \n", + " \n", + " dense_3 (Dense) (None, 1) 9 \n", + " \n", + "=================================================================\n", + "Total params: 1,457\n", + "Trainable params: 1,457\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "Epoch 1/100\n", + "50/50 - 3s - loss: 0.1823 - 3s/epoch - 53ms/step\n", + "Epoch 2/100\n", + "50/50 - 0s - loss: 0.0071 - 485ms/epoch - 10ms/step\n", + "Epoch 3/100\n", + "50/50 - 1s - loss: 0.0017 - 583ms/epoch - 12ms/step\n", + "Epoch 4/100\n", + "50/50 - 1s - loss: 0.0015 - 518ms/epoch - 10ms/step\n", + "Epoch 5/100\n", + "50/50 - 0s - loss: 0.0013 - 455ms/epoch - 9ms/step\n", + "Epoch 6/100\n", + "50/50 - 0s - loss: 0.0012 - 459ms/epoch - 9ms/step\n", + "Epoch 7/100\n", + "50/50 - 0s - loss: 0.0010 - 451ms/epoch - 9ms/step\n", + "Epoch 8/100\n", + "50/50 - 0s - loss: 7.6110e-04 - 451ms/epoch - 9ms/step\n", + "Epoch 9/100\n", + "50/50 - 0s - loss: 6.2400e-04 - 453ms/epoch - 9ms/step\n", + "Epoch 10/100\n", + "50/50 - 0s - loss: 5.0527e-04 - 454ms/epoch - 9ms/step\n", + "Epoch 11/100\n", + "50/50 - 0s - loss: 4.7144e-04 - 452ms/epoch - 9ms/step\n", + "Epoch 12/100\n", + "50/50 - 0s - loss: 3.8245e-04 - 455ms/epoch - 9ms/step\n", + "Epoch 13/100\n", + "50/50 - 0s - loss: 3.7650e-04 - 453ms/epoch - 9ms/step\n", + "Epoch 14/100\n", + "50/50 - 0s - loss: 3.7521e-04 - 455ms/epoch - 9ms/step\n", + "Epoch 15/100\n", + "50/50 - 0s - loss: 2.7278e-04 - 453ms/epoch - 9ms/step\n", + "Epoch 16/100\n", + "50/50 - 0s - loss: 2.5569e-04 - 452ms/epoch - 9ms/step\n", + "Epoch 17/100\n", + "50/50 - 0s - loss: 2.3474e-04 - 452ms/epoch - 9ms/step\n", + "Epoch 18/100\n", + "50/50 - 1s - loss: 2.3310e-04 - 544ms/epoch - 11ms/step\n", + "Epoch 19/100\n", + "50/50 - 1s - loss: 1.8887e-04 - 580ms/epoch - 12ms/step\n", + "Epoch 20/100\n", + "50/50 - 1s - loss: 2.0727e-04 - 579ms/epoch - 12ms/step\n", + "Epoch 21/100\n", + "50/50 - 1s - loss: 1.6970e-04 - 531ms/epoch - 11ms/step\n", + "Epoch 22/100\n", + "50/50 - 0s - loss: 2.1364e-04 - 459ms/epoch - 9ms/step\n", + "Epoch 23/100\n", + "50/50 - 0s - loss: 1.6468e-04 - 466ms/epoch - 9ms/step\n", + "Epoch 24/100\n", + "50/50 - 0s - loss: 1.8675e-04 - 454ms/epoch - 9ms/step\n", + "Epoch 25/100\n", + "50/50 - 0s - loss: 1.7464e-04 - 455ms/epoch - 9ms/step\n", + "Epoch 26/100\n", + "50/50 - 0s - loss: 1.7150e-04 - 454ms/epoch - 9ms/step\n", + "Epoch 27/100\n", + "50/50 - 0s - loss: 1.7167e-04 - 453ms/epoch - 9ms/step\n", + "Epoch 28/100\n", + "50/50 - 0s - loss: 1.5447e-04 - 456ms/epoch - 9ms/step\n", + "Epoch 29/100\n", + "50/50 - 1s - loss: 1.6784e-04 - 516ms/epoch - 10ms/step\n", + "Epoch 30/100\n", + "50/50 - 1s - loss: 1.5286e-04 - 573ms/epoch - 11ms/step\n", + "Epoch 31/100\n", + "50/50 - 1s - loss: 1.5793e-04 - 565ms/epoch - 11ms/step\n", + "Epoch 32/100\n", + "50/50 - 1s - loss: 1.6390e-04 - 533ms/epoch - 11ms/step\n", + "Epoch 33/100\n", + "50/50 - 0s - loss: 1.6676e-04 - 461ms/epoch - 9ms/step\n", + "Epoch 34/100\n", + "50/50 - 0s - loss: 1.8529e-04 - 464ms/epoch - 9ms/step\n", + "Epoch 35/100\n", + "50/50 - 0s - loss: 1.3479e-04 - 455ms/epoch - 9ms/step\n", + "Epoch 36/100\n", + "50/50 - 0s - loss: 1.6066e-04 - 451ms/epoch - 9ms/step\n", + "Epoch 37/100\n", + "50/50 - 0s - loss: 1.4952e-04 - 454ms/epoch - 9ms/step\n", + "Epoch 38/100\n", + "50/50 - 1s - loss: 1.6409e-04 - 542ms/epoch - 11ms/step\n", + "Epoch 39/100\n", + "50/50 - 1s - loss: 1.5115e-04 - 565ms/epoch - 11ms/step\n", + "Epoch 40/100\n", + "50/50 - 1s - loss: 1.3440e-04 - 529ms/epoch - 11ms/step\n", + "Epoch 41/100\n", + "50/50 - 1s - loss: 1.5595e-04 - 505ms/epoch - 10ms/step\n", + "Epoch 42/100\n", + "50/50 - 1s - loss: 1.4974e-04 - 551ms/epoch - 11ms/step\n", + "Epoch 43/100\n", + "50/50 - 0s - loss: 1.4582e-04 - 457ms/epoch - 9ms/step\n", + "Epoch 44/100\n", + "50/50 - 1s - loss: 1.3210e-04 - 531ms/epoch - 11ms/step\n", + "Epoch 45/100\n", + "50/50 - 1s - loss: 1.5804e-04 - 559ms/epoch - 11ms/step\n", + "Epoch 46/100\n", + "50/50 - 0s - loss: 1.4973e-04 - 459ms/epoch - 9ms/step\n", + "Epoch 47/100\n", + "50/50 - 0s - loss: 1.9301e-04 - 469ms/epoch - 9ms/step\n", + "Epoch 48/100\n", + "50/50 - 0s - loss: 1.1564e-04 - 452ms/epoch - 9ms/step\n", + "Epoch 49/100\n", + "50/50 - 0s - loss: 1.4595e-04 - 489ms/epoch - 10ms/step\n", + "Epoch 50/100\n", + "50/50 - 1s - loss: 1.4399e-04 - 568ms/epoch - 11ms/step\n", + "Epoch 51/100\n", + "50/50 - 1s - loss: 1.6464e-04 - 540ms/epoch - 11ms/step\n", + "Epoch 52/100\n", + "50/50 - 1s - loss: 1.1713e-04 - 586ms/epoch - 12ms/step\n", + "Epoch 53/100\n", + "50/50 - 1s - loss: 1.5229e-04 - 555ms/epoch - 11ms/step\n", + "Epoch 54/100\n", + "50/50 - 1s - loss: 1.2272e-04 - 558ms/epoch - 11ms/step\n", + "Epoch 55/100\n", + "50/50 - 0s - loss: 1.4453e-04 - 496ms/epoch - 10ms/step\n", + "Epoch 56/100\n", + "50/50 - 1s - loss: 1.0907e-04 - 593ms/epoch - 12ms/step\n", + "Epoch 57/100\n", + "50/50 - 1s - loss: 1.5891e-04 - 524ms/epoch - 10ms/step\n", + "Epoch 58/100\n", + "50/50 - 0s - loss: 1.4634e-04 - 458ms/epoch - 9ms/step\n", + "Epoch 59/100\n", + "50/50 - 0s - loss: 1.4984e-04 - 456ms/epoch - 9ms/step\n", + "Epoch 60/100\n", + "50/50 - 0s - loss: 1.3223e-04 - 495ms/epoch - 10ms/step\n", + "Epoch 61/100\n", + "50/50 - 1s - loss: 1.2282e-04 - 552ms/epoch - 11ms/step\n", + "Epoch 62/100\n", + "50/50 - 0s - loss: 1.2260e-04 - 457ms/epoch - 9ms/step\n", + "Epoch 63/100\n", + "50/50 - 0s - loss: 1.4930e-04 - 494ms/epoch - 10ms/step\n", + "Epoch 64/100\n", + "50/50 - 0s - loss: 1.2384e-04 - 452ms/epoch - 9ms/step\n", + "Epoch 65/100\n", + "50/50 - 0s - loss: 1.4297e-04 - 458ms/epoch - 9ms/step\n", + "Epoch 66/100\n", + "50/50 - 1s - loss: 1.1002e-04 - 517ms/epoch - 10ms/step\n", + "Epoch 67/100\n", + "50/50 - 1s - loss: 1.3300e-04 - 505ms/epoch - 10ms/step\n", + "Epoch 68/100\n", + "50/50 - 1s - loss: 1.2980e-04 - 517ms/epoch - 10ms/step\n", + "Epoch 69/100\n", + "50/50 - 1s - loss: 1.3353e-04 - 515ms/epoch - 10ms/step\n", + "Epoch 70/100\n", + "50/50 - 1s - loss: 1.4278e-04 - 511ms/epoch - 10ms/step\n", + "Epoch 71/100\n", + "50/50 - 1s - loss: 1.3547e-04 - 515ms/epoch - 10ms/step\n", + "Epoch 72/100\n", + "50/50 - 1s - loss: 1.3195e-04 - 519ms/epoch - 10ms/step\n", + "Epoch 73/100\n", + "50/50 - 0s - loss: 1.3806e-04 - 482ms/epoch - 10ms/step\n", + "Epoch 74/100\n", + "50/50 - 0s - loss: 1.2993e-04 - 453ms/epoch - 9ms/step\n", + "Epoch 75/100\n", + "50/50 - 0s - loss: 1.1680e-04 - 454ms/epoch - 9ms/step\n", + "Epoch 76/100\n", + "50/50 - 0s - loss: 1.4084e-04 - 453ms/epoch - 9ms/step\n", + "Epoch 77/100\n", + "50/50 - 0s - loss: 1.2300e-04 - 452ms/epoch - 9ms/step\n", + "Epoch 78/100\n", + "50/50 - 0s - loss: 1.3992e-04 - 452ms/epoch - 9ms/step\n", + "Epoch 79/100\n", + "50/50 - 0s - loss: 1.1784e-04 - 450ms/epoch - 9ms/step\n", + "Epoch 80/100\n", + "50/50 - 0s - loss: 1.1756e-04 - 451ms/epoch - 9ms/step\n", + "Epoch 81/100\n", + "50/50 - 0s - loss: 1.1931e-04 - 453ms/epoch - 9ms/step\n", + "Epoch 82/100\n", + "50/50 - 0s - loss: 1.0862e-04 - 452ms/epoch - 9ms/step\n", + "Epoch 83/100\n", + "50/50 - 0s - loss: 1.2957e-04 - 453ms/epoch - 9ms/step\n", + "Epoch 84/100\n", + "50/50 - 0s - loss: 1.1890e-04 - 451ms/epoch - 9ms/step\n", + "Epoch 85/100\n", + "50/50 - 0s - loss: 1.2060e-04 - 452ms/epoch - 9ms/step\n", + "Epoch 86/100\n", + "50/50 - 0s - loss: 9.6054e-05 - 451ms/epoch - 9ms/step\n", + "Epoch 87/100\n", + "50/50 - 0s - loss: 1.2433e-04 - 451ms/epoch - 9ms/step\n", + "Epoch 88/100\n", + "50/50 - 0s - loss: 1.3120e-04 - 451ms/epoch - 9ms/step\n", + "Epoch 89/100\n", + "50/50 - 0s - loss: 9.3067e-05 - 453ms/epoch - 9ms/step\n", + "Epoch 90/100\n", + "50/50 - 0s - loss: 1.0844e-04 - 451ms/epoch - 9ms/step\n", + "Epoch 91/100\n", + "50/50 - 0s - loss: 1.2138e-04 - 453ms/epoch - 9ms/step\n", + "Epoch 92/100\n", + "50/50 - 0s - loss: 9.8372e-05 - 451ms/epoch - 9ms/step\n", + "Epoch 93/100\n", + "50/50 - 0s - loss: 1.1158e-04 - 452ms/epoch - 9ms/step\n", + "Epoch 94/100\n", + "50/50 - 0s - loss: 1.1435e-04 - 452ms/epoch - 9ms/step\n", + "Epoch 95/100\n", + "50/50 - 0s - loss: 1.1319e-04 - 453ms/epoch - 9ms/step\n", + "Epoch 96/100\n", + "50/50 - 0s - loss: 9.1814e-05 - 452ms/epoch - 9ms/step\n", + "Epoch 97/100\n", + "50/50 - 0s - loss: 1.0696e-04 - 450ms/epoch - 9ms/step\n", + "Epoch 98/100\n", + "50/50 - 0s - loss: 1.0741e-04 - 451ms/epoch - 9ms/step\n", + "Epoch 99/100\n", + "50/50 - 0s - loss: 1.0522e-04 - 449ms/epoch - 9ms/step\n", + "Epoch 100/100\n", + "50/50 - 0s - loss: 1.0165e-04 - 450ms/epoch - 9ms/step\n", + "3.525180363794789e-05\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGdCAYAAAAfTAk2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAACZi0lEQVR4nOydd5ilZXn/P+/pU8/0Xrf3wlJ2FxAQWKodAcsSDWIQjSLhp9moiZpEokkUNUGjgkRFwYgoKgILSnMLbIVts3V2eu/l9Pf3x/ucszOzbWb3lPecc3+ua66EmXfOec547/N8n7tquq7rCIIgCIIgpBCWRC9AEARBEAQh2ojAEQRBEAQh5RCBIwiCIAhCyiECRxAEQRCElEMEjiAIgiAIKYcIHEEQBEEQUg4ROIIgCIIgpBwicARBEARBSDlsiV5AIgiFQrS1tZGTk4OmaYlejiAIgiAI00DXdYaHh6moqMBiObOPJi0FTltbG9XV1YlehiAIgiAI50BzczNVVVVnfCYtBU5OTg5g/IFyc3MTvBpBEARBEKbD0NAQ1dXVkXP8TKSlwAmHpXJzc0XgCIIgCEKSMZ30EkkyFgRBEAQh5RCBIwiCIAhCyiECRxAEQRCElEMEjiAIgiAIKYcIHEEQBEEQUg4ROIIgCIIgpBwicARBEARBSDlE4AiCIAiCkHKIwBEEQRAEIeUQgSMIgiAIQsoRU4Hzyiuv8I53vIOKigo0TeM3v/nNWX/n5ZdfZtWqVbhcLmbNmsX3v//9k5558sknWbRoEU6nk0WLFvHUU0/FYPWCIAiCICQrMRU4o6OjLF++nP/6r/+a1vPHjh3jxhtv5PLLL2fnzp38wz/8A5/+9Kd58sknI89s3ryZ2267jfXr17N7927Wr1/PrbfeytatW2P1MQRBEARBSDI0Xdf1uLyRpvHUU0/x7ne/+7TPfP7zn+fpp59m//79ke/dfffd7N69m82bNwNw2223MTQ0xB//+MfIM9dffz35+fn84he/mNZahoaGcLvdDA4OpuawzY634NDz4BmC0sWw8B1gz0j0qgQzEwpB46tw/C8QCkDVxTB3HVgkii2cAb8HDj0HbbvA5oI5V0PVhYlelZDCzOT8NtU08c2bN7Nu3bpJ37vuuut4+OGH8fv92O12Nm/ezGc/+9mTnnnwwQfjuFKT4hmC398Le56c9O2RrFpsH/gZrqpliVmXYG76jsGvPw4tr0/69kDJJeSsfwxrTnGCFiaYmsa/wG8+AQPHT3zvpa/RO+82Cm/9L7A5Erc2QcBkScYdHR2UlpZO+l5paSmBQICenp4zPtPR0XHa1/V6vQwNDU36SjnG++HHN8CeJwlh4fnQhTwaWEennkf26HF8P7qeHa+/kuhVCmajaz/86GpoeR2vlsGTwct5PHAlY7qTvK6ttH3rSo42NSV6lYLZ2P97+Mm7YOA4fZYCfha4mj8ELyakaxQefILd33wHgyPjiV6lkOaYSuCAEcqaSDiCNvH7p3pm6vcm8sADD+B2uyNf1dXVUVyxCQgF4Yn10LmHIVsB7/F+mY/77uP3lZ/l+4t/zlvafHIZpeQPH+WF7fvP/npCejDaCz+7BcZ6OWKbw5Xj3+D+wCd4Ye4X+c6cH9JBIdWhFroe+SD72wYSvVrBLLTthCfvhJCfF7U1XDb2H/yr9nGeX/wN/rviAcZ1B8vHtvDcdz5B/6gv0asV0hhThajKyspO8sR0dXVhs9koLCw84zNTvToT2bBhA/fdd1/kv4eGhlJL5Gz6DjS+is+ayftHP8dhrZZ/f99S3n+h8Rk9Q3+k+7uXUeVvY8tv/549ZT9hSaU7wYsWEoquwx8+C0MtdNqreO/w59Ay8/nlHRdyUV0BAL3Hahj/3+tZzVv8+yNfo/Sz/0JBloQd0hq/B379NxDwsNV2IR8fuYdZJW4e+chFVBdkAitpfi2P6hfu5hbvb/inH1/OP33io9isprtLC2mAqaxuzZo1bNy4cdL3nn/+eS688ELsdvsZn1m7du1pX9fpdJKbmzvpK2XoboA//SsA/+hdT4New1feuTgibgBcuYUUfPjHANxieYmf/Pyn+IOhhCxXMAl7n4J9vyWk2bhz5G7GrDk8/FcnxA1AYf1KuOYrANzt/wn/+as/J2q1gll46WvQ08CwvZC/GbmLotxMfnrnJUrcGFRf9gEG570fi6ZzR9d/8sgrBxO4YCGdianAGRkZYdeuXezatQswysB37dpFk4rpb9iwgTvuuCPy/N13383x48e577772L9/P4888ggPP/ww999/f+SZz3zmMzz//PN8/etf58CBA3z961/nhRde4N57743lRzEvG/8JQn7esF/E44G3cc3CUj50Sc1Jj1lrV+NZ8VEA7hj+IT965Wi8VyqYhYDXsBvgB/q72aPP4tNvn8uq2oKTHs1Y+3HGSlaRo42z+ND3eKmhK96rFcxCfyNsfgiA+8Y+wgA5/Nv7llHmdp30qPvd38DjKGCupZWmP/2ItgHJxxHiT0wFzrZt21i5ciUrV64E4L777mPlypX84z/+IwDt7e0RsQNQX1/PM888w0svvcSKFSv453/+Z77zne/wvve9L/LM2rVrefzxx/nxj3/MsmXLePTRR3niiSe45JJLYvlRzEnja3Dwj4Q0K58fuY1sp52vvXfJafORXNd+Cb81kyWWRvb86Rf0jHjjvGDBFLzxIxhsYthezIOem1hQlsPdV84+9bMWC5k3fw2A91tf4dE/vEwoFJfOEoLZ+PPXIOTnTcdKNgZX8d6VlVw1v+TUz2YW4Lzq/wHwCcuv+c5ze+K4UEEwiFsfHDORMn1wHr0ZGl/ladv1fHrkDj57zTw+c83cM/6K/sJX0F77JntCdfx+9eP8/Y0L47RYwRT4x+FbS2Cshy+GPs7PfFfy449cxFULTnNQhX/t0Xdhb3yJxwNXknHLQ7xrRWWcFiyYgu6D8N8XAzo3e/+Fg5Y5vPT/rqQi7wz9tfwefN9ajmOsgy/5P8r6T/8z80pz4rZkITWZyfltqhwcYQa07YTGVwlpNh4YuYn8TDt/fVndWX9NW/u3BK0ZLLE0sm/LH6XKId3Y/TiM9TDgKOMXvsu5oCaPK+efvc+N/e0bAHiP9S/8/E87SMN7UXqz5SFA5w3nGvbos/jAxdVnFjcAdheOK4zijo9Yn+XhVw7Hfp2CMAEROMnKJmP8xauOy2mnkL9aW0eOy37238sswLL8NgBu1Z/l569Lj5O0IRRSBxX8wLeOIFY+9fY5Z2yxEKH6EgJlK3Bqflb1/o7NR3tjvFjBNIz2wm6jS/w3hq7FZtFOH9KcyooPErTnMNvSTvebz0lYXIgrInCSkZEu2PcbwNhw7FaND54isfh0aBffBcA6yzZ+//o+yalIF47+GXoO4rNl8xPP26gtzOTKeWcOTUXQNGyXfByA91hf48evHYvhQgVTseNRCHhoyZjPG/p8rltcRrl7mqNfnDlYVtwOwE28xmNb5EIlxA8ROMnI7l9AKMDxjEXs1eu4aWk5JTknVzKclrIlhIoX4tCCLB56jVcP98RurYJ52PkzAJ61XsEImaxfXYvFMg3vTZiFN6NbHMy1tNLSsI2OQU+MFiqYBl2HnY8B8NDoVYDG+jW1M3oJbektgHGh+s0bR+RCJcQNETjJhq7Djp8C8MjYZQB84OLpe2/CWJa8F4CbLVv4xVa5VaU8Y31w4PcA/M/QpTisFm5ZVTWz13C50eZeC8CNli38dldrtFcpmI2WN6DvCAFrBr/1XcSckmwuqT+5ncAZqboYPaeCHG2cecNb2HJMwptCfBCBk2y0vAG9hwhYM3jSezFV+RmTmrNNm8XvAeBSyx52NBxhyOOP8kIFU/HWryDooyNzHnv1Ot6+oIS8zHPoShwRxpt5cnuzJBunOrt+DsAmx6WMksF7VlZOL2drIhYLWthurJt5crsIYyE+iMBJNtSk8Nddaxkhk3evqJxZmCFM0Vz00sXYtSCXhbbz3J7TDysVUoA9vwLg595LAXj3ynMs8553PbrVQb2lk2D3Qfa2peDgWsHAPw57fg3A9weNPmPvWlFxbq+16F0AXGHZzcY9zYz7glFZomBC/OPwm3vgN5+EwZaELkUETjIRCsG+3wLw4wGjeeI5H1SANu8GAK6y7uLp3W3nvz7BnAy2QvNWdDQeH72QXJeNqxacvTT8lDiz0eqM0OjbLTt55q32KC5UMBUHnwPvIMPOMjaHFnJxXQFV+Zln/71TUbkKPbOQXG2cRYH9vHxQOmKnLK89CLseg10/g+9fBuP9CVuKCJxkouV1GG7Hb8vm5eBS5pVmM6ck+9xfb951ALzN8iZbj3TRJz1xUpP9vwOgKXsZXeRz7aIynDbrub/eXMNu3m7ZxbN7xfOXsii7+ZP1UnQs3Ly8/Nxfy2JFm2Pkb11l2cmz4jFOTXQd3vq/yH/uLX0XfkfiBjuLwEkm9v4GgB0Za/BhZ92isvN7vcpVkJGPWxtjuX5QblWpimop8BvvKgCuXVR6fq83bx0AF1oa6O7u5nDX8Pm9nmA+Aj449DwAPxlYCsA1C6NjN1dbdvLi/i58ARn4m3J0N0DfEUIWO8s8P+Ce9huxnUsKRZQQgZMsTAhP/WTQCE+d90FlscKcawAjTPXifhE4KcdQOzRtAeAXwytx2iy8bV7R+b1mwSwonItdC3K55U25jacija+Ad4hxZxE7QnNYXJF79s7FZ2P21eialTmWNvJ8rfzliLSnSDlUpebBrFUMkc2Vi84hKT2KiMBJFtp3wnAbAVsWG32LKc11srQyCq4/FW64yrKTlw924w/KrSqlaPgDoNOes5QOCrlsThGZDtv5v64Kb77duouNIoxTj/3GQfW6YzU6lvO/TAFk5KHVrAGM8OafD4jdpBwH/gDAr8aMS/g10bCb80AETrJwaCMAB7IuwoedaxeVnlv11FTmXI2OxkJLM5meLt5o7Dv/1xTMg7KbjcELgCh4/cKofjiXWd7izZZ+mWmWSoRC0PAMAD+NVngqzFzDY3yZZQ+vHOyOzmsK5mCwFdp2oKPxm9FlZDttXFJfmNAlicBJFtRB9fToIiCKG05mAVr5MgAuseznT3IbTx38Hjj2CgC/6F8AwNsXTnM0w9movgSsDsq0furo4DXphp06tO+EkU4C9mxe9i+k3O1iccWZpzZPm7q3AcZe09Q7QmPPaHReV0g8B/8IQHvuMnpws2Z2IQ5bYiWGCJxkYLQHWrcD8JuRxTislugq47rLAVht2cefxG2cOjRtAv8Y464S9us1LK7IndlIjzNhz4CqiwBYY9knt/FU4vCLxv/JWoUfG1fOL45eHkX5cnDkkKuNsUhr5JVDYjcpw+E/AfCKbniL3zb3PHP9ooAInGTg8IuATl/OfLrIZ1VtPhmO8yjznYoSOGst+zjaM0r74Hj0XltIHIdeAOAt14WAxmVzorzhTBDGrxzqlq7GqYISOM97FwNwaTTtxmqDOqPZ5BrLPl5uEIGTEgT9EW/x431zALhs7jn22ooiInCSgcNGeGqr1VDGl0VbGdeuAc1CnaWTMnrZdFhmxaQEym5+O2KENaN6UAHUGwJnjWUfnUMeGjqlXDzp8Qwa42CAXw7MB2DNrCjnUdSdsJvNR3vxBqSrcdLT/Dr4hvE589kdrKUqP4O6wnNsChlFROCYnVAIjhiuv8cHjDyKqB9ULrfhOgZWW/az6YgInKSn/zj0HETXrPxuZD4Oq+XcZpadicoLweaiWBtkttYmYapU4OjLoAcZya6jRS9mUXkuhdnO6L6HEsYXWxvw+nzsOD4Q3dcX4o86oxoyL0THwuVzixJaHh5GBI7Z6WmAsV6Ctgw2eerJcdmiUx4+lQnhhs1HeiTckOw0vgZAt3sJQ2RxQW1edMOaAHbXpDycrUelAi/pUWGG3Q7DW3zpnBhUwZQuBVce2YyzVDvGVpkunvwcfQmAZz2Gt/hyE4SnQASO+Tn+FwDaspfix8ba2YVYY9EZMuw2tu6nbdBDY+9Y9N9DiB9NmwDYwUKA6OffhKk/URXzemMfwZAI46TmuGE3zwzPBmLgLQawWKDWyMO50NIgwjjZ8Y1C+y4AfjswC4hBWPMcEYFjdtSG83rICE+tnR2jg6r6YgBqtU4KGWSTdBlNbpTd/H6wHoC1sRI41caU6VWWwwx7AhzokOniSctYH3TtA+C54VnYrRoX10c5rBlG7TerLAfZ0dQveTjJTMsbEAownlFGi17E/NIc8rMciV4VIALH3Oh65KD63UAdQPTzKMJk5EGxIaIusBySPJxkZqgd+o6io/Hy+GxcdktswppgzDPTLFRoPZTSJ7fxZKZ5K6AznFVHD26WVrqj0/X6VChhfJH1EN5AkLdaBmPzPkLsOb4ZgMMZywCNi+rzE7ueCYjAMTP9x2C4nZDFzmbfLHKcNuaX5cTu/dSt6gLLIbY39kseTrKiwlP9uQsYJpOV1fnYrTH6p+7MhlKjnPgCyyFePyYCJ2lRl6n9ziVADC9TABUrwGKniAGqtG62it0kLyqN4hXvXCDGdjNDROCYGbXhdOcuxouDVXX5scm/CVN1QuB0DHloHZB+OEmJulHtsRrC46K6GN+oqk6EG15v7BNhnKw0GXbz5zGjj8mFsTyo7BmgOqhfoB1iy1HxGCclAR+0bAPg6f5agNiFNc8BEThmRgmcnZqRmR5zZaw8OCssx7ARYPvx/ti+nxAblN1sHDUS/mJ6UEEk3HCh9TB9oz4OdY3E9v2E6OMbhbadAPxO5W2tqo2xMI7kbx1k+/F+AjLoN/lo3w2BcfyOPA6GKqjKz6DcfZ5T56OICBwz07QFgD8O1QFwYaw3nMK54MrDiZeFWpMInGRkfAC69gLwx6F6LBqsrMmL7XtWG6XiS7RjOPGJ3SQjLdsgFMCjEkVnF2dREOtEUXWhush6mDFfkAMd0igy6VDh8ONZy9CxcLGJwlMgAse8jPVB3xEAXh6txWG1sLw6L7bvabFE+ppcYDnEtkY5qJKOth0AjGZV04ObheW55LjssX3P/HrIKsZGgMVaIzubxG6SjlYjzHAsYwmgxSePQoU2F2jHycTDzuaB2L+nEF2aXwdga0Dl35goPAUicMxLq3FQDWfVMEAOSypzcdmj3KjtVExIND7QMcSINxD79xSiR4sxlPWow6iIi8tBpWmT8rd2Ng3E/j2F6KLsZqvPCE/FPKwJ4K6EnAoshFiiHRNhnIyoc+q5wSoALqgxTwUViMAxL+pGFT6o4mY4lUYH05W2Y4R02CWHVXKh7GaLOqhiHp4KU7kSgKWWYxzuHmHI44/P+wrnj65H7ObZAeOginn+TZiKE3Yje02SMdQGw23omoVtvlqyHFbmlGQnelWTEIFjVlrCB5WRKBrz8FSYcmPDqdHbyWFM8imSCV2P2M3zg9UArIiz3ay0NaLr8Gaz9DVJGgZbYKQTXbOyM1BLXqY9foMSIwLnKEd7Rukf9cXnfYXzR+01g9lzGMPF0ip3bKt8zwEROGZkwo0q7PpbXpUXn/fOKgR3DQCLLY281ToQn/cVzp+B4zDWQ8hi581ANXmZdmoK4nVQrQCgRm8jmzEJNyQTrUZ4qj9nLl4cLK10x29QohI4F9iOA7CrZSA+7yucP8puDtqNqfNxu4TPgLgInIceeoj6+npcLherVq3i1VdfPe2zH/nIR9A07aSvxYsXR5559NFHT/mMx+OJx8eJPX1HYbyfkNXJW4Ea8jPtVBfEsfSuwpgsvlQ7yu6WQelrkiyoG1Vf9jy8OFhWlRe/gyqrCNyG12iJpVESRpMJdZlqsKmDKl6XKZggjFuVMB6I33sL54cSOJs9dQCsTEeB88QTT3DvvffyhS98gZ07d3L55Zdzww030NTUdMrnv/3tb9Pe3h75am5upqCggPe///2TnsvNzZ30XHt7Oy6XK9YfJz6og6o3ez5+bPE9qADKVwCwzHKM7mEvnUPe+L23cO6oDafBNg+A5VUxGs9wOtRhFU4YFWGcJKgE403jdQAsi6fdTBXG4vlLDkLBSN+kZ8NRhnQUON/85je58847+djHPsbChQt58MEHqa6u5nvf+94pn3e73ZSVlUW+tm3bRn9/Px/96EcnPadp2qTnysrKYv1R4oe6Ue23qoMq3oaj3MYr7Ybb+E1xGycHShj/RR1Ucb2JQ0QYr7Aeo3/MT1OfTKQ3PcFAZBL0c4OVQCL2mxWAIYzfFI9xctDdAL4RgrZMGoKVlOQ4Kcs1n4MhpgLH5/Oxfft21q1bN+n769atY9OmTdN6jYcffphrrrmG2traSd8fGRmhtraWqqoqbr75Znbu3Hna1/B6vQwNDU36MjXqoHp13PjM8b+JGwKnKtRGDmO8KYPwzE/AZ3QV5UTe1rLqxNjNSlsjAHtaTf7vTDCmh/vHCNhzOBSqoDTXSWm8D6qIMD7K4Lifln4ZEWN6lLe4K3shISysqI5zlGGaxFTg9PT0EAwGKS0tnfT90tJSOjo6zvr77e3t/PGPf+RjH/vYpO8vWLCARx99lKeffppf/OIXuFwuLr30Ug4dOnTK13nggQdwu92Rr+rq6nP/ULEm4IWOtwB4TpVsLov3TTyzYFKi8ZutInBMT9deCHoJONwcCZVR7nZRkhPng0oJnEoljN8SuzE/6qDqzF6IjiX+ew1MSDRuBBC7SQZUlGGPZjT4M2N4CuKUZDxV2em6Pi219+ijj5KXl8e73/3uSd9fvXo1H/7wh1m+fDmXX345v/zlL5k3bx7f/e53T/k6GzZsYHBwMPLV3Nx8zp8l5nTth5Afv8NNk15CZV4GxTnO+K9DuY2Xakd5q2VA3MZmp20XAB1ZCwEt/uEpMIRxniGMl1iOsbdNDirTozpf7w0fVPH2FkNE4FSE2slllD0icMyPEsYvjxr/3uPWjmKGxFTgFBUVYbVaT/LWdHV1neTVmYqu6zzyyCOsX78eh+PMM1EsFgsXXXTRaT04TqeT3NzcSV+mRYUZOjPnAxrL4x1mCKMEznKVTyFuY5Oj7GYfRoO/uIenwqhww1LtKHtaJZ/C9LS/CcBrownKv4FJwthoTSECx9QEvMZFHHhp2LCbpYkQxtMgpgLH4XCwatUqNm7cOOn7GzduZO3atWf83ZdffpnDhw9z5513nvV9dF1n165dlJeXn9d6TUGHseHspw5IQHgqjDqoVtrCicay6ZgaZTd/Ga0AEpBgHEYJ42WWRvrH/LQOiDA2LUG/kYMDvDRk7J3LKvMSsxa13yzRjrG3bUiEsZnp2g+hAH6Hmxa9iNrCTHJjPe/uHIl5iOq+++7jRz/6EY888gj79+/ns5/9LE1NTdx9992AET664447Tvq9hx9+mEsuuYQlS5ac9LOvfOUrPPfccxw9epRdu3Zx5513smvXrshrJjXqJr553Mi/WVKR2Jt4eaidTDxSSWVmggHoNCaIvzxsCJyE2U2Z0UNpmb0FkERjU9N9AII+AvYcmvQSagszcWcm6KAqWwrAIkszfaM+2gZTpKdZKqIuU11ZRpRhcYV5IyK2WL/BbbfdRm9vL1/96ldpb29nyZIlPPPMM5GqqPb29pN64gwODvLkk0/y7W9/+5SvOTAwwMc//nE6Ojpwu92sXLmSV155hYsvvjjWHye2hILQsQeAl9WNamF5TmLWklUIOeVYhtuZrzXzZktlYtYhnJ2egxDwELBnc9xTSmVeRuIOqlKjIWdVqBUnPva0DnL9khRq4ZBKtIcPqnkwnOCDqtS4yC53NIMf9rQOUpkXx+amwvRRdtOg1QGwqDyNBQ7APffcwz333HPKnz366KMnfc/tdjM2dvoeGt/61rf41re+Fa3lmYeeQxAYJ2jL5JinnLJcF4XZCUgwDlO6GIbbWWhp4pmORdNODhfijLpR9WTNQx+2sCiRB1VOGWQWYhnrZa7Wwp42EcamRdnNIYsx725hWQLtpswQODWhFuwE2NM6yHWLRRibEmU3W1WUYXGivMXTQGZRmQkVnurJnkeIBB9UELmNL7I0MTDmp2NI3MamRNnNIYuRYJzQG5WmRexmoaVJEo3NTPvkgyqh+427GpxubHqA2VqbVFKZlQlRhj8PGgI04efUGRCBYyaUMj6sblQJj22WGnHxFQ4jn2Jfm+RTmBJ1UL3uMSpREr7hKLtZbGmiZ8Qnoz7MSCgU2W/+rMLhCbWbicJYO85brZJobEr6joJ/lJDVxeFQBUXZDkoS0cZkmojAMRPqJv6GVx1UiY5tqg1njn4c0NnfLgLHdEw8qAaN1gsJtxsVbljpaAWkcZsp6T8GvhFCVicHg+XkZ9oT32pf2c1CSxM9I166hkUYmw51RvWpKMPC8lxTpy2IwDELuh65iZvG9Vc0F6wOXKExqrRu9rcPJ3Y9wskMNIJ3iJDVyYFgBTkuG1X5CU7OVMJ4rt4I6BwQYWw+1EHVnz2XIFYWVZjgoFKJxhc4DWEsFyoToi5TR2zhKIN5829ABI556G8E7yAhi4N9gQqynTaq8zMTuyarHYrnA7BQa2KfbDjmQ4nigew5BLCxyAw3quIFoFnJDA1TRh8HOkQYmw51UB2zzwFM4PWDiMCZh9F7S+zGhKj9ZpvXJOHwsyACxyyo+VNDObPxY2NheQ4Wiwlcf2rTWaA10dg7ypgvkOAFCZOYelCZYcOxOaFoHmCEG/Z3iDA2HcqDs8NnzOUzhd2ULATNQm6wnyIGaRCBYy50/aRweMLzRM+CCByzoDqKHreZoBJmIircsMLRgq7Lrcp0qAZ/u/1GObZp7CacT6E10dgziscfTPCChEkouwmHwxeawW4cmVAwG4CFluMSojIbw+0w1ouuWXnLX0mG3UpdYVaiV3VGROCYBbXh7Amog8osylh5cBZbjQGlUkllMjoNYfzqYAlgJrsxhPFyRzMhHQ51jiR4QUKE0V4Y6QRgt7cch9XC7OLsBC9KMaGS6kj3CL5AKMELEiKovWYkuw4vDhaU52A1Q5ThDIjAMQvKg/OX4XAljEmSt5TAKQ20kYFHblVmwjMEg0YX8O2eCuxWjbklCep8PRVVKr5ECWMJU5mILuMyNZZVzRgu5pVlY7ea5ChQnr+lthb8QZ2jPSKMTYOymzaHEWVYUGaSveYMmMSq0xz/uNFfAHhjrAJNg7mlJrlRZRdDVgkaOvO1FhE4ZqL7AACejFKGyGZ2cTYOm0n+SZcuAqA80IYDPwekAs88qEnQbU4TdDCeSolhN4vtbQBiN2ZC2c3+kJG3Na9UBI4wHboPgB7C7yygGzd1hVm47NZEr+oEJQsAmGtp4UDHMKGQNOAyBSqs2ZVh5C2YasPJKQenGwtB6rV2DogHxzwouzmkGx2M55vpJl5s7DXVwWYshMTzZyaU3WwbM6IM882035wGEThmQBlOd+ZsQGNuiUm8N2GKFwIw39LGmC9I68B4ghckAJGw5mGMkk1THVSaFmkxMFdr5UDHsHSmNQvKbraNGx2MTSWM8+vA5sKu+6jSusWDYxaCAehuAODVIUPgzDPTfnMaROCYAZW8dcxiTFg31UEFkYNqmbMdgIOdsumYAmU3OzwVAOYTxsrzN8/SSt+oj+4R6UybcEKhSKjhtfBBZSaBY7EaDUaBeVqLeP7MQt9RCHoJ2jJp0ospzHJQlMhB0NNEBI4ZUMlbu33GQWWqDQeM/hTAbIyZVA0icBKPrkfs5tUho4LKfMLYEDjLXYYwltu4CRhsMkY0WBwcCZWS67JRmmuyg0rZzVytlc4hL32jvgQvSAh7/QayZ6NjMd8ZdRpE4JiBcKmvulGZ9aAqDHSSiUdKfs3AcAeM96NrVvYHynHZLYnvfD0V5fmbZ1EJo3IbTzxqrxnOrieAjXmlOYnvfD0Vtd+siAhjsZuEowROs82kUYbTIAIn0Yz2wGgXYPSksFs18zVPyiyArGIA5mitEqIyA8p7M5pdhw87c0tM0vl6Iip3q8Tfgp2AeHDMgLKbVlXqa8o8CiVwFlgNYSz7jQlQeaJ7A0YFlQgcYXoowxlXPSnqi7LMU+o7kQlu48NdIwSlkiqxqJt4uNTXlC7j3Apw5mLVg9RpHRzuFs9fwlH5N/uCqoLKjHajQuIVgSY0QhzqErtJOMqDs3nEhHlbZ8CEJ2maoQynw4ylvhMJ36psrXgDIZr7xhK8oDRH2U2DHr5RmSzBGCZVUs3TWjjcNSItBhKNEsavjxkjGkzTb2si+XVgdWIPeanSukXgJBrfKPQdAyYKHBPazSkQgZNowj0pwqW+phU4xkG13NkBiNs44YR7UoyHDypz2818aytjviBtg9JiIGEEfNB7CDhRQWXK/cZijQxrDQtjIYF0NwA6flchvbipzMsgx2VP9KqmhQicRKNu4ttVqa8pY+IQcRvPUpVUcqtKIBN6UrwyoCqozHhQQSQPZ4VqMSB2k0B6DkIoQNCRS5teQGGWg0KzlvpGmosaLQZ6pcVA4lBnVE9mOMqQHN4bEIGTWEIh6DLa7b8yaCTxmj1EVejvIAMPDTJVPHGonhQhWyaNoSJynDbK3a5Er+rUFJ84qAAOSwVe4lAHVX/2HEAz714DEc/fCuUxFmGcQKb0aTPtJfwUiMBJJEMt4B9Ft9g56C/BabNQU2CyUt8wWUWQWYiGzmytTUJUiaTbSBQdzDF6UswtzTZfqW8YdVCFK6kOdYndJAwlcJpUqa+pb+LK87fAaghjETgJRNnNm34jymBab/EpEIGTSLoPAjCaXUsQK3NLs809fl5tOnO1Vo52jxIIhhK8oDRF2U2rzYQjGqbirgJHNlY9SK3WIQdVIlF2s89v8nA4RELileFKKrlQJQ4VDt80ZEQZTL3fTEEETiJR06DbHeEblckNR93GF9na8AVDHJdKqsTQY2w4DUETzhKaytRKqs4RmUmVKJTdvD5SBJjcbqZWUkloMzF4hmDY6Ee0a7wUTYPZxSb2/E1BBE4iURvOEb0SMPmGA5FbVXgmldyqEoS6Ue0YMxKMTW83yvM3z9LKsDdA55AkjMadgC9S6rt1WOX7lZjYbqZUUonnL0H0GFV3voxihsiiKj8Dl92a4EVNHxE4iUS5jN/0GCWbc8yujNVNPDyT6qDcquJPKBTZdLYMGTdx0w3ZnEq4xYArnDAqwjju9B0BPUjQnk0n+ZTkOHFnmrzUt9gQOLO1NnpGvPTLTKr4oy7hfRl1QBKcUVMQgZModD1iPJvVQTXb7AdVkXFQFfg7cOCXoZuJYLAZAuOELA4aQ8XkOG0U55i01DeMmg49x6IEjgjj+KO8foNZ9YDGHLPvNQCFht0sdXUDSCfsRKDsptlqNBRNpvAUiMBJHKM9xrBENPb5S7FbNarzMxK9qjOTXQLOXCyEqNU6OSJu4/jTMzkxfVaJiSuowqhQQ1mgRVrvJ4qeyYnpSXFQKWE8zybCOGEouzkQMPL9TH8Jn4IInEShvDeerCq8OKgrzMJmNfn/HJoGhXMAw218rGdUWu/HG3Wj6nQaiemzi002mPVU5NWCxY495KWcPhHGiUDZzaGQOqiSwW6UwKkKhkvFxWMcd5TdbBs18v2SQhhPwOQnagqjDKfHFT6oksRwwrcqazveQIjWAWm9H1dU5V04MT0p7MZqgwJjevVsSxsHu4alkireqAvVznEj3y8pbuLqMpUV6MfNiIxsiDcBL/Qbielbho00iqQIbU5ABE6iUAKn0aJimyVJcKOCCXHxLgCOSFw8viiX8VtedVAlg8CBiN3M1toZGPPTKwmj8SMUgp7DAGweKgSSxG4cWZCrhLzWJiGqeNN7BPQQQXsOnXoe+Zl2CrIciV7VjIiLwHnooYeor6/H5XKxatUqXn311dM++9JLL6Fp2klfBw4cmPTck08+yaJFi3A6nSxatIinnnoq1h8juqgb1V6/MSwxKTYcgCLjVhVOGD3SPZrI1aQXuh4RxuHE9DnJIoyV5295hpEwKp2w48hgEwTG0S0OjgWLyXRYKcs16WiPqSgvzixLOx1DHoY8/gQvKI1QZ9RgtpGYnjRn1ARiLnCeeOIJ7r33Xr7whS+wc+dOLr/8cm644QaamprO+HsNDQ20t7dHvubOnRv52ebNm7nttttYv349u3fvZv369dx6661s3bo11h8neqgS8ddVT4qkMR51Ey8PtAC6eHDiyWg3eAbQ0djjLcFq0agpSC6BE04YFWEcR9ReM5JTZySmF2dhMXPH9ImoBPWlzk4AjordxA9lN212IzE92cJTEAeB881vfpM777yTj33sYyxcuJAHH3yQ6upqvve9753x90pKSigrK4t8Wa0nmgs9+OCDXHvttWzYsIEFCxawYcMGrr76ah588MEYf5ooMaE75LZRQ+DMSoakP4DC2YCGKzhMIUOSMBpPlPfGk12NFwe1BZk4bEkSZVbCuDpo9FA6KsI4fqibeJfqmD6rKIkOKiWMF9qNkLjYTRzpCSemG6M9kuYSPoGY7o4+n4/t27ezbt26Sd9ft24dmzZtOuPvrly5kvLycq6++mr+/Oc/T/rZ5s2bT3rN66677rSv6fV6GRoamvSVUFSjNr/qDlma6yTHZfKmW2HsGZCn8oa0NrmJxxO14fSqpluzkmnDUQdVrr+LDDxyE48nShgfJYkS08OoEFUtxoVQ7CaOKA/O7nFVQZUs4fAJxFTg9PT0EAwGKS0tnfT90tJSOjo6Tvk75eXl/OAHP+DJJ5/k17/+NfPnz+fqq6/mlVdeiTzT0dExo9d84IEHcLvdka/q6urz/GTniTqo+jNVZUkybTgQuY3PsrTTM+JlcEzi4nFBbTjHtSRLTAfILICMAgBmaR0c7ZGbeNxQAufNcGJ6MtmNEsZFvhasBMVu4kUoCL3GRXzToJGYPqfYxKM9TkNc/NtTG5Hpun7a5mTz58/nrrvu4oILLmDNmjU89NBD3HTTTfzHf/zHOb/mhg0bGBwcjHw1Nzefx6eJAuHukMnUdGsiatNZ6lSVVLLpxIdkTUwPo/IpZmlttPSP4/EHE7ygNGBCx/TwaI+kspvcKrBlYNUDVGtd4sGJFwNNEPCgWxwcCRThsFmoNHsj2lMQU4FTVFSE1Wo9ybPS1dV1kgfmTKxevZpDhw5F/rusrGxGr+l0OsnNzZ30lVCUwGkIJFHTrYkot/FChyT+xRVlN2+MJOFBBZEKvIWODnQdjvfKNPqYM9IFnkF0NN70FKNpUF+URPuNxXKikkprp7FXmovGhXDH9HBielEW1mRJTJ9ATAWOw+Fg1apVbNy4cdL3N27cyNq1a6f9Ojt37qS8vDzy32vWrDnpNZ9//vkZvWZCUTeq7WPh2GayHVSGB6dGN+LiUkkVBzyDMGxMcd8SqbxLooMKIqHNJU6jVPyYeP5ij9prvCoxPdmmQQMRYTzP2o7HH6JtUJqLxhx1mepyJlkj2inYYv0G9913H+vXr+fCCy9kzZo1/OAHP6CpqYm7774bMMJHra2t/OQnPwGMCqm6ujoWL16Mz+fjZz/7GU8++SRPPvlk5DU/85nP8La3vY2vf/3rvOtd7+K3v/0tL7zwAq+99lqsP8754/dAfyNwIraZdMajQg0FvjbsBKSSKh6EE9MzSxj2ZFKU7SAvM7maboWF8SzCwlg8fzGne3JietLtNRARxstc3eA3PMZV+ZkJXlSK0zMlMT3ZLuGKmAuc2267jd7eXr761a/S3t7OkiVLeOaZZ6itNZRhe3v7pJ44Pp+P+++/n9bWVjIyMli8eDF/+MMfuPHGGyPPrF27lscff5wvfvGLfOlLX2L27Nk88cQTXHLJJbH+OOdP/zGjO6Qjh3aPO7maboXJKQdHNhbfCDVaJ0e63YleUeqjXMYDmfXQl2QVVGGUMC71N6MRktBmPFB202SpApJU4Ci7mWM1PJhHu0d427ziRK4o9eme2jE9ybzFipgLHIB77rmHe+6555Q/e/TRRyf99+c+9zk+97nPnfU1b7nlFm655ZZoLC++9B0FYCSrBoa05Gq6FUbTjH447buZrbXxp94q/MEQdrMPC01meo8A0GoNH1RJuOHk14HFhj3koYx+jvYUJHpFqU+vMaJhf7ImpkMkRFUZUD2UekQYxxwljLckWyPaKciJFG+UwOmyJ/GNCiJu4/m2TgIhnaY+SRiNKcpujgSTc6ovAFa7IXKAWZY2jnaPytDNWKPsZueoEQ5PmoaiE5kwdDOXEfH8xZqxPvAMAPDmmHEJScr9BhE48UdtOI2hJBuWOJVwqXh46Kbk4cQWZTdvjSdp3laYcA8lrYPBcT99MnQzdgR8Rrkv8PpQHpCkduPMgWxjv6zTOqWbcazpMyaI+zJLGcdFhdtFhiPJEtMVInDijQo17PMapb5JeaOCE6WbVtVCXdzGsUPXIwJn62AekKQHFUDBLAAWu3oAsZuYMtgMeoiQzUWnnkeuy0ZRdpIlpocpmA1AndZB26CHMV8gwQtKYdReM+gyGorWJ+sZhQic+KPU8c6RfCDJ5sJMpMDowlwWaAWgUQ6q2DHWC94hdDSOBopwWJOz6RYAhYbAmS+zhWJPON8vswbQmFWcfdpmqKZH2c3CSIsB2W9ihrKbdqvRmqWuUASOMB0CXuNWBewZNzw4dUVJWu6oblTZ/l6yGJcNJ5aoDcebWYYXBzWFmUnZdAuI2E2VHq6IEbuJGcpb3O0wSn1nJVODv6kou1nkMASO2E0MUfvNMZVGkVSNIacgAiee9B8HdIL2bHrIpTTXSaYjLoVs0ScjDzKNfJA6rVMETixRG06/y0hMT+YblTGN3uihZCUovXBiibKbJt2ooKpL4oMqbDf1FqODvQicGNJnCOM9HuMSLgJHmB5qwxnOrAa05D6oIHKrqtU66Br2MuqVuHhMUHbTZqkAkjhvC4zZQlYnVj1AudYr3YxjibKbBp9R6pvMB1V4rynxGyFxsZsYouxmx3AekNx2IwInnihl3GlLgYMKIgmj4bh4Y6/cqmKC2nAOB4wS8aQWxhZLpFS8XuugqW+MQDCU2DWlKpEScaPUN5kPqnDOnyswhJsRSU6PFeMDRs4fcMBXjNWiUV2QpGkUiMCJL2rDOR52GSfzQQURt/GisMDpkV44MaE37DJWIcFkzdsKo+xmrq0Tf1CnuV9mC0WdYAAGjgPw5ljYbpJ4v3FkGR3UMYSx9FCKEf2qRNxVxCgZVOVnJHUD1+RdeTKiBM5+bzjBOIk3HIh4cOo1Y6q4eHBihLKb7cNG5V1S38QhYjfLMoybolRSxYDBZggFCFmddJBPUbaTbGeS5vuFKTiRhzPiDdA97E3wglKQcIl4hioRT/K9RgROPAnHNkdS5KBSN/HSgDE8URL/YsCErqLHgsW47BZKc5JsdtlUlN3MsRrCWOwmBkRKxKvQsVCf7F4/iJSKh4WxJKjHgBQqEQcROPFjQlfRfd5iNA1qkji2CURu4ln+XrIZEw9OLFB9k7wZRlfRusIknF02FXUTrwgZpeLHxG6ijzqouu1GiXiyH1RAxG4WOIweSsfFbqKP2m+OBo0S8WTPExWBEy8Gmowp4rYMusmjwp2By56c7a8juNyQaYTbarVOafYXC9RB1ec0SsST3usHEWGc5zVKxeWgigHqoGoiBUrEwyjPXw2GMG7slZy/qKP2m73hfL8kF8YicOJFuEQ8wygRT4mDCiKbTp3WSe+oj8Fxf4IXlGKES8TDLuNUsJvcSrC5sOgBKrUeSU6PBVNKxJO6yV8Y5cEp8rUAulyoYkGK5fuJwIkXynA67UaJeNJXwoRRm85iV7iSSjadqDKlRLw+yW9UgCoVN8p+67UO2gbH8fiDCV5UijGlRDwlhLFqL+AMjJDPsITEo413BEaMvLjDgWIcVgsVeUk6EkYhAideRKaIGy7j+mSdQTUVFW4It1CXTSfKqN5J4SniKXFQQcTzN8/eja5Dc594caJGKBgp992rutEme6gBAEem4f3DEMbHe8ekVDyaKJvxO/MZIju5R8IoRODEC3VQhUvEU6KqASKVDXWqhbqMbIgy4Zu4qrxLHc+fYTdLM8LCWARO1BhqhaCPkMVOm15IWa6LDEeS5/uFUXYzy9rJuD9Il5SKRw+11wykwkgYhQiceBEpEVcu4xQwHmBCC3WjVFxCVFFkQlfRxlAp2U4bxdnOxK4pWqiDarbFqIgRu4kiaq8ZzawihCV1RDFEPH9LXT2AXKiiypQS8WSvoAIROPEh6I+UiB/0J3/760mogyrT30c2YxyTm3j0UC5jr+oqWleUiaYlt8s4QmG4VFwJYwltRo9IibiR75fsiaKTUBeqeSokLhV4UUTZTbhEPBUu4SJw4sGErqKd5Cd9++tJuHIhy6jUqNM6ONY9InHxaBGeIu5MHZdxBHVQub3t2AiIwIkm4ZEwpMhImImES8V11UNJKvCiR184b8vI90sFYZwip6zJURvOUEa16iqa/IYziYITpeJDngD9Y1IqHhWU3bRa1AyeVLKbnHKwZUipeCxQB1WDNwWmiE9F7TXFvlZAFw9ONJmSRpEKdiMCJx70hkvEU6ir6ETCcfEMiYtHld4UmiI+FYtlwiwzo1TcG5BS8aigDqpdqTBFfCr5dYCGIzhCIUOy10QL/7iRnA4cDZaQYbdSmpv8+X4icOJBpETciG2m1IYDUGD0NFnokF44UUXZTcqViIdRdjPf3iWl4tEiFIp4cPb7itA0UiffD8DuArcK2UqpePTobwTAb8+lnxzqirJSIt9PBE48SLUp4lNRbuNaTUrFo8qUm3hKdKOdSGG4SaSqFJMw1fkz0gGBcUKajRa9ODVGwkxFCeM6i5SKR41JJeJayrQxEYETDyJdRY1eJil3UKlQQ7EqFZfhiVHAOwyjRgl1k16KO8NOfpYjwYuKMqqb8SybKhUXuzl/wiXiGRUEsaaetxgidrMkox8Qj3FUmFIinip2IwIn1oSCEfffYX9JSrS/Pgl1o8r095HFuGw40UCFGXyOfIbISj2vH0TspjxoeP5E4ESBqVPEU+QmPgllN/Oke3r0SMEScRCBE3sGmyHkJ2Sx004h1QUZSd/++iRcbsgwwig1WheNPaMSFz9fwlPEVVfR+sIUPKjUTTzP14aFkISookGv0TG9idQ6qCah7KYGY26SdMGOAspu9nhSK99PBE6smVAiHkrFEvEw6lZVa+lk1BekZ8SX4AUlOWq0R6uWQlPEp+KuAosda8hPGX1yE48Gar854EvBEvEwaq8pku7p0UN5jHerfL/aFElMF4ETa9SG06W6itYUpOCGA5Fb1dKMPkA6jJ434SniKeYynoTFCnk1gCGM2wakVPy8UQfVrlSaIj4Vtddk+PvJZkw8OOdLwGtEGoBjoTIy7FaKc5K/RBxE4MQeteEc142DqjYVQw1wouTXYfTCOS6bzvkR7iqqSsRrUtxu5tq6CenQ3Dee4AUlMboeEcYH/cVYNKjOT0G7ceVCplGRWqt1cbxXQuLnRf9xQCdgy6KHXGoKUmckjAicWBN2Gauuoil7UOWHQ1RGRcxx6Wlyfii72T2WWi7jkwhXxGQanj8JN5wHI13gH0XXLLToxZS7M3DYUnSLn1AqPuYL0i2l4udOJI3CKBFPpTMqLtb/0EMPUV9fj8vlYtWqVbz66qunffbXv/411157LcXFxeTm5rJmzRqee+65Sc88+uijaJp20pfH44n1R5k5KnlrV4rFNk9CbTilAWNGjISozgPfKAwbf8dGvYxsp42CVCsRD6PsZo5NKmLOG3VQjbnK8WFPXW8xnAiJZxql4tJ76zxQdtNhM9IoUumMirnAeeKJJ7j33nv5whe+wM6dO7n88su54YYbaGpqOuXzr7zyCtdeey3PPPMM27dv56qrruId73gHO3funPRcbm4u7e3tk75cLlesP87MCAUjE6EbAiVYNKhKRZcxRDacbG8HNgISojofwl1FHW4GyU4pl/FJqB5KlSGjVFzs5jwIl4ir4awpLXAiIfHwVHGxm3Mm0mnfGM6aSnZji/UbfPOb3+TOO+/kYx/7GAAPPvggzz33HN/73vd44IEHTnr+wQcfnPTfX/va1/jtb3/L7373O1auXBn5vqZplJWVxXTt581QGwR9Rom4XkhFfgq7jHPKjOGJgXEqtR6a+lLnH0ncUV6/AVcVDKXWhnMSShjnq+GJ4sE5D9RB1aKmiKdsQQOcCIlrRkhcmoueB5HKu3C+X+rYTUxPW5/Px/bt21m3bt2k769bt45NmzZN6zVCoRDDw8MUFBRM+v7IyAi1tbVUVVVx8803n+ThmYjX62VoaGjSV1yIdBWtJIg1tQ8qTVOD8KBW66Rv1MeQR6aKnxORrqKq8i6V7Sa/FgBHYIR8hkXgnA/Kbg4FjHy/lN5vlOevJGCUiktI/DwId9ofSb00ipgKnJ6eHoLBIKWlpZO+X1paSkdHx7Re4z//8z8ZHR3l1ltvjXxvwYIFPProozz99NP84he/wOVycemll3Lo0KFTvsYDDzyA2+2OfFVXV5/7h5oJqpdJuKtoSt+oIOI2XqRmCzWJ2/jcCHcVDaVwiXgYewbkqNi/1kVr/zi+QCjBi0pSlN28OaZu4il0UJ2E2muyPB048HNMmkSeG0E/DBjpIgf9JVgtGpX5qdNpPy7xkqn5A7quTyun4Be/+AVf/vKXeeKJJygpKYl8f/Xq1Xz4wx9m+fLlXH755fzyl79k3rx5fPe73z3l62zYsIHBwcHIV3Nz8/l9oOmiNpxmLfVim6dEuY0XOQ2BI3HxcyQ8nNWjSmFT+aCCE6337apUvF/sZsZMKBEPT59P6f0mqxjsWWjoVGndNEmp+Lkx0AR6kKDVRSf5VOS5sFtTJ40ipp+kqKgIq9V6kremq6vrJK/OVJ544gnuvPNOfvnLX3LNNdec8VmLxcJFF110Wg+O0+kkNzd30ldcUL1MDvqVyzhNDqpZVhmeeF4ou9mhhrOmdIgKTioVF8/fOTDWC94hdDSa9RIKshzkuOyJXlXs0LSTuqf3jkr39Bmj9prhzGpAozbFogwxFTgOh4NVq1axcePGSd/fuHEja9euPe3v/eIXv+AjH/kIP//5z7npppvO+j66rrNr1y7Ky8vPe81RJdLLJMWbtYVRB1VZyChxloPqHPCPw1ALAEcCpditGuXu1HEZn5KCOgDm2MMVMSKMZ4zaazwZZXhxpHZ4KozK+TvRPV32mxkzZThrqp1RMa+iuu+++1i/fj0XXngha9as4Qc/+AFNTU3cfffdgBE+am1t5Sc/+QlgiJs77riDb3/726xevTri/cnIyMDtdgPwla98hdWrVzN37lyGhob4zne+w65du/jv//7vWH+c6RMKRdTxnnGVvJXKuRQQuVHledsAneN9clDNGFUiHrBn0+fJYVZ+ZuoNZ52KEsbVujE8sUm6Gc+c8HBWp3FQpXR4KozabxY4e2EEmvpGWVWbn+BFJRnKbo7rKo0ixYRxzAXObbfdRm9vL1/96ldpb29nyZIlPPPMM9TWGtUT7e3tk3ri/M///A+BQIBPfvKTfPKTn4x8/6/+6q949NFHARgYGODjH/84HR0duN1uVq5cySuvvMLFF18c648zfUY6ITAe6SpamOUg2xnzP3dicVeDZsEW9FDCAE29Ke55iAVKFA9lVMNwanUVPS3qoCr0twLGQSXMEHVQtVoML3aqHVSnRAnjeosSxr0ijGeMspsGv8r3S7H9Ji4n7j333MM999xzyp+FRUuYl1566ayv961vfYtvfetbUVhZDFEN/sYzygmM29LjoLI5DJEzcJxarZNtQ/l4/EFcdmuiV5Y8KLvpTMGuoqdFlfxmenvIwCOhhnNBCePDAaMYI5V6mZwWZTelQdU9XYTxzAmnUahO+6lW6Zs66dJmQ4Ua+hzKZZwOBxWcqIhx9KDr0CIVMTNDHVRNenh2WWptOKckIx9ceQDUaF009Y0RCklFzIzoDw9nDYfD02C/UXuN29OGRkhy/mZKKAgDxwHY50nNPFEROLFCCZw2i1EtlhYHFZyoiMmQUvFzQtlNgzdNSsTDFITDDV14AyG6ZHjizFB2s1tV3qWF3eRWgcWGNeSjjH4Z8DtThtsh6EPXbLTphRRlp14ahQicWBF2GadLiXiYk4YnyqYzI9RNPOwyToubOEwYnhiuiJFww7TxDsOoqkALlZBht1Kc40zwouKA1QZ5NYBRKt497GXMF0jwopIIdUaNZVYQwpKSlXcicGKFulHt86TnQVUZroiRg2r6hIKRrqINai5MdQpuOqckMjyxB0Bu4zOh3wgz+Bz5DJOZ2sNZp6L2mwXKbprEbqaPOqN6wmkUKRhlEIETK9RNfFe6NGsLE66I8RkVMXJQzYAJw1nb9ELKcl3pk6A9ZXii5FPMALXXDLlUYnq67DUQ2W8kJH4OKLtp04w0ilS0GxE4scA7EnEZN4VKyHRYKc5OA5cxRJpvOf0D5DAmG85MUBvOWIZyGafghnNa1EFVElTDE0UYTx8VauiwpqPAMSqpwt3TRRjPAOXBOZzCw1lF4MQCZTh+Rx5DZKWXy9iZY8yJAWq0Tlr6xwhKRcz0UHbT60ijEvEwyoOT42nHRkBCDTNB2c3xUBpV3oVRdlOhGw1hpVR8BihhvHdMRRlSrEQcRODEBrXhDCqXcSomb50RtenMtnXjD+q0DUgDrmmhNpwWUtdlfFpyysHqxKIHqdB6JXdrJijP336vGrKZTvuN8vwVqO7p0gV7BoQr78ZSN09UBE4s6A+7jFVX0RQ0nDOiNp2lEhefGVNcxml1E7dYTgxP1DrpH/Mz5PEneFFJgrKbXSOqRDyd9hsVEncEhsljRITxdPEMwrgabhsqJsthpTDLkeBFRR8ROLEg4jI2uoqmYnb6Gck/0ewPxG08bZQw3jOWRr1MJqLsZpHLEMaSTzENgoFI5d2RQDFWi0ZFXhqNSLFnGN4/DGHc0j9OIBhK8KKSAHVG+ZyFjJJBTWFWSqZRiMCJBX1TXMbpdKOCyE28hnCpuBxU00LZzZsp7DI+I8puFjnF8zdthlogFCBkcdBBPpV5GditabatR0LiXQRCOu2DngQvKAlQe82AK7U77afZv4Q4cVJX0fT04BQHjIqYRnEbn53xfvAMANCkl5DrspGXmXou4zMSHp6oKmLE8zcN1F4zklGJjiX9RDFEKqmWZoSbRIowPivKbjosaop4itqNCJxoM6FZ2xF/MTaLRkWeK8GLijPqJp7l6cSBXzac6aA2HK+ziHFc6RfWhIjdlIeMihjx/E0DdRPvsadpQQNAQR0Ac+0SEp82KhzeGAoPZ01NuxGBE22GWiHkJ2Sx00EBlfkZ2NLNZZxVDPYsNHSq1fBEXZdS8TOiBE7YZZyqG84ZUR6cfG8roIswng7KbpoJ5/ulr91US0h8+kxNo0jRKEOanbxxYILLOFXne5wVTYvcxussXYz5gnSPyPDEM6I2nHaLSphMR7vJqwHNgi04TjGD0gtnOqib+CG/MZw1FXuZnBW11xT7VZNIEThnJ5xGMZIHpK4wFoETbSIu4zQtEQ+jyjeXqLi43KrOgjqojgVTt6voWbE5jAnRQK3WQdvgOL6AVMSckXBi+mgaloiHUR6cTF83GXikC/bZCPphsAWAw4ESbBaNcndqplGIwIk2YZexrpq1peONCiK3qoUuqYiZFlOGs6blTRwm5VPoOrT0i92cFl2P2M1+b9iDk4YCJ7MAXG4AarQumnpHJSR+JgabQQ8StDrpxk1VCqdRpOanSiRTXcbpeKOCSGVDnRqeeFwqqc5MXyMAu0bTtEQ8jLKbyPBEuY2fnvF+8A4B0KwXU5TtJMtpS/CiEkR4WKulk1FfkL5RX4IXZGKU128kowodS0o3FBWBE23UjerNsTR2GUNkwymV4YlnJ+Az+pkAjcFiHDYLZbmp6TI+K8pu5qiKGAltngF1mfK4ivHgTN+9Bk4IY5cqFZf95vSoM6rblvr5fiJwoo1Sxw0qOz0tXcYQCVHletrQCEmI6kwMNoMeImjNoBs31fkZWCyp11V0Wii7qQoPTxS7OT1qr+lzpHaztmmh7GaBU7pgnxUljNOh8k4ETjSZ0qytOMdJpiNNXca5VWCxYQ35KKNfKmLOhDqohjMqAS09e+CEUR6cQp/h+WuSnianRx1UbRYj3y9tw+EwKUQFIozPiPLgHPSlft6WCJxo0n8cAE+4WVsKG85ZsdqMsl+MTadv1MewDE88Neqg6rKlcbO2MOom7vL3k82YHFRnQh1URwOpfxM/K8puygLtgDT7OyMq3+/EFPHUvVCJwIkmRfPgzhd4fu4/AWl+o4ITwxNlttCZCQ9nDVfepbPdOHMg07hZ1qomkaGQVMScEnVQpX3lHUT2mhxvOzYCEqI6HboeuVClQxqFCJxo4siE6ot4VV8OpHGJeJjw8ERVESNhqtMQcRmn6XDWqUxoEukNhKRJ5OmYUtBQl852k1MOVicWPUiF1itJxqdjrBd8I+hotOjFlOQ4yXBYE72qmCECJwaE/3Gl/UEVnvJr7QbEg3NapjRrS+ubOETsZmmmmi0kdnMyAa8xFgY4Hiol22mjICvNhrNOxGKJCONarZPuYS9jvkCCF2VC1F7jySjFiyPlzygRODEg7B5N+xCV2nAqQkZcXBJGT8GEZm0H/UVoGlQXZCR2TYlG2c18Rzi0KXZzEv3HAZ2ALZNecqkpyETT0rTyLkx+2G5UiwHx4pyMCk/1RYazpvZlSgROlPH4g3QMeYA0L9sEGZ44HUa7wT+Krllo0Yspz3XhtKWuy3haqJ4mNZoanigH1ckoUTzkqsKovEvzvQYiwnixdE8/PcpuWi1lQOqHNUXgRJlmtRnnpLvLGCLzqByBYfIYkQ3nVCiX8ZirDD828fpBRBiXyPDE06Nu4p1Wo1mb2A0Ru6lXIfFmEcYno/abIwFj5l2q240InChzfEJ4Ku1dxo5MyDZuCrVaJ22D43gDwQQvymSEXcYOw2Wc9onpELmJZ3s7ceCXhNFToQ6q47oazip2E7GbShUSF2F8CsIz78bDnfZT225E4EQZSTCegtp0TgxPHE/wgkxG2GWsSbO2CFnFYM9CQ6dK66ZJcnBORtnNATVkU/YbToTEfW2ALsL4VKgL1ZvhHjgpnkYhAifKhDfjVE/emjaRihhjRoz0p5iCuokfVi5jOagATYsI4xqtk/4xP0PSJHIy6qDaPZoHpHYvk2mTVwOaBVtwnGIGRBhPxT8Ow8q7pZeS47KRl2lP8KJiS1wEzkMPPUR9fT0ul4tVq1bx6quvnvH5l19+mVWrVuFyuZg1axbf//73T3rmySefZNGiRTidThYtWsRTTz0Vq+XPiMZe8eBMIuLBCZeKy6YzCXUT3xO5UYkwBiL5W4tkttDJTKi8OxoswW7VqMhL88o7AJsD3FWAERJv6R8nEAwleFEmQnXa99uzGSCb2jRIo4i5wHniiSe49957+cIXvsDOnTu5/PLLueGGG2hqajrl88eOHePGG2/k8ssvZ+fOnfzDP/wDn/70p3nyyScjz2zevJnbbruN9evXs3v3btavX8+tt97K1q1bY/1xzkq44iPVXX/TRnlwqlAzYsRtPBl1E987rrrRijA2UMJ4oUuaRJ7EcAcEPOiahVa9iKr8TKzpOpx1KhN6bwVCOu2DngQvyESovWYwXHmXBpepmAucb37zm9x555187GMfY+HChTz44INUV1fzve9975TPf//736empoYHH3yQhQsX8rGPfYy//uu/5j/+4z8izzz44INce+21bNiwgQULFrBhwwauvvpqHnzwwVh/nDMSDOm09EsPnEmog6ooPDxRbuIn8I3CiBJ+egl5mXbcGantMp426qCaJcMTT0YdVKOucgLYJDw1kbDnL7MfELuZhAqHd6oS8XQ4o2IqcHw+H9u3b2fdunWTvr9u3To2bdp0yt/ZvHnzSc9fd911bNu2Db/ff8ZnTveaXq+XoaGhSV+xoG1gHH9Qx27VKHeLyxiIHFSZ3i6c+MSDMxHlMvbZ3QyRLV6/iaiDqjTUBUiTyEmo8FSPatYm4fAJqAG/s+2qF47YzQmU3RwLqeGsabDfxFTg9PT0EAwGKS0tnfT90tJSOjo6Tvk7HR0dp3w+EAjQ09NzxmdO95oPPPAAbrc78lVdXX2uH+mMjPuDrKjOY2mlW1zGYTILwJENYFTEyPDEE0RcxqqraIqXbM6IvFrj//jakSaRU1A38RZU5V0aHFTTRtlNlaa6GYvdnEDtNwfCQzbTQBjHJcl4aiKTrutnTG461fNTvz+T19ywYQODg4ORr+bm5hmtf7rMK83hN5+8lF/fc2lMXj8p0bTIplNr6cEXCNE5LHFxIHKjarcYzdrS4UY1bfKMS4gtOE4BwyJwJqIOqkOBcIm4COMIyoNTGJDQ5kmEh7OOpkcPHIixwCkqKsJqtZ7kWenq6jrJAxOmrKzslM/bbDYKCwvP+MzpXtPpdJKbmzvpS4gj+YbAWZolcfFJhJu1hdKjq+iMsDmNCdEYnr/2wXF8AamIASIH1Vuq8k48OBNQAifL24mVoITEw4RCkZD40VAJDquFslxXghcVe2IqcBwOB6tWrWLjxo2Tvr9x40bWrl17yt9Zs2bNSc8///zzXHjhhdjt9jM+c7rXFBKM8uDMc0ovnEmom/i+cLM2Oagmow6rWbZeQjqRBP60RwnjhnCoQezmBNmlYHVg0YOU0UdT72gkApDWDLdB0EtIs9GuF1JVkJEWaRQxD1Hdd999/OhHP+KRRx5h//79fPazn6WpqYm7774bMMJHd9xxR+T5u+++m+PHj3Pfffexf/9+HnnkER5++GHuv//+yDOf+cxneP755/n617/OgQMH+PrXv84LL7zAvffeG+uPI5wLKmG01mLExSXxT5GGLuMZoYTxkqwBQFoMAOAdhjGVX6KXUpLjJMOR5sNZJ2KxRHrhVFt6GPUF6R31JXhRJkDtNaMZ5QSxps1lyhbrN7jtttvo7e3lq1/9Ku3t7SxZsoRnnnmG2lpj82pvb5/UE6e+vp5nnnmGz372s/z3f/83FRUVfOc73+F973tf5Jm1a9fy+OOP88UvfpEvfelLzJ49myeeeIJLLrkk1h9HOBdUiKo0JHHxCKFgxGXcGCzGabNQkuNM8KJMhvLgzLFLs78I6qDyOvIY9mSyQMKaJ5NXC31HWZLZx5YRY78pyk7zf1vK69dtC1fepcdlKuYCB+Cee+7hnnvuOeXPHn300ZO+d8UVV7Bjx44zvuYtt9zCLbfcEo3lCbFGeXDyPC2ALk3bAIbaIOQnZLHTTiGzCzKxpIHLeEYUzgagFpkqHkEdVANqOKuMhDkFhbPh6J9Z7OyBEaPFwKra/ESvKrGocHhzmlXeySwqIfYUzALNgt0/TDEDclBBZMMZcVUQwiK9TE5F0TwASn2Gh1d64RDx4LSFK+/Ebk6mcA4Ac6xGIYrsN0Ts5pA/vYazisARYo/NGfHizLG0MTjuZ2AszePiYZex3Tio5CZ+CormApDp7SaHMTmoICKMj4ZkOOtpUQKnPNgKSGgTiOw3J/L90sNuROAI8UHdxle4jM60aX9YqRtVk666iqbJhjMjXG7INtrKz9bapEkkRA6q/eNSQXVaVGgzf7wZjZAkp8MkD46mQVV+etiNCBwhPiiBs8yl3MbpvumEm7X5pAfOGSk27GautQ1vIETXsDfBC0owU3rgpEuy6Ixw14DFjjXkpYJejvemeWjTMwjjqkWHXkJZrguXPT0q70TgCPFBCZzZWnjoZppvOuES8THlMpab+KlRdrPc1Q2Q3odVMACDRhf2Jr2EbKeN/EwZznoSVltkyG+9pYOeER8j3kCCF5VAlNfP4yxklIy08vqJwBHig3IblwYl8Q+IbDqH/EVY0shlPGPUsNY5dtVDKZ3tZqgFQgGCFgcd5FNTkHnGkTdpjcrDWexUw1rT2W7UZarfkX7DWUXgCPFB9TTJ8XZiSfe4+Hg/eAYA4yZe7s7AYZN/iqdE9VCqQuVupXMllRLFw65KdKm8OzPqQrXEaXj+0roCT4XD2zQjny2dwpqyqwrxIaccLDYseoBS+uVGheEyHsclB9WZUN2MCwPtQJp7cNRB1WUzDirJ2zoDyoMzyyrNRcPC+EhQ5ftJiEoQoozFCrmGi7RS66ZjyIPHH0zwohKE2nB6HZVAermMZ4zy4GT4B8jEk95NIpUwPq4bzdpqpbXA6VEe49JQ2PMndrN3PJyYnj77jQgcIX6o2/gchzFVvDldN51wszblMpYeOGfA5QZXHgDVWpfcxIEGX3o1azsn3NXG//F1Anqae4wNu4kInDTab0TgCPFDbToLMweBNHYbqw3nSEAOqmmhmkRWa90MjvsZHPMndj2JQtnNW6pZWzqFGmaMGrhpD47hZjR9c7cCPhhsAQzPnzvDjjuNKu9E4AjxI88QOLPV8MS0dRv3hW9U0qxtWqgw1UKX0csjLQ8rXY8MZz0SLMZu1ajIy0jwokyMPQMyjQtEpdZDa/84vkAowYtKAIPNoIcIWl10k5d2lykROEL8UHHxCs0o+U3bXjjqoNrnSb+Y+DmhQpsLnErgpKPnb6wPvEMANOslVOVnYpXhrGdGXajqbH2EdGgdGE/wghKA8voNuioBLe0uUyJwhPihQlRFAVXZkI4enIDP6GcCNOmlFGQ5yHGlj8v4nFAenFpruOQ3De1G5W2NOUvw4qA6zQ6qc0KFqRZnGcIwLZtEKrvptKbncFYROEL8UDeqLE87aZv4N9AEeoiANYNu3Gl3ozon8uoAKAuFS37T8aAKV96pZm1iN2fHbXiMw0UNaSmMVTj8eHg4axolGIMIHCGe5FYBGtaglyKGaO4fI5huwxPVjSrsMk63G9U5oTw4ed42QE/PEJU6qFo1VSIudnN2VEi8xhIe85GGdqP2mwNeIx8p3XonicAR4ofNAblG75d6Wxf+oE77YJrFxdVNvCPsMpab+NlxVwMatuA4hQyl501cHVSH/enXrO2cKZgFQGnAmH+XzgLnrfDMOxE4ghBD1BC8C7LUdNt023TCzdpC4Sni6eUyPifsLqMTNkapeFo2iVTCeM94+KASuzkrSuC4x5sBPf3GNeh6xPN3LFSCw2ahNMeV4EXFFxE4QnxRM2IWuYxKqsZ0EzhqwzngNUrE0+1Gdc6oMNVcRy+6Di396Wk3DeFQg3hwzk5eDWgWrMFxihmgqW+MUDqFxEe7wT+KjkaLXkxtQSaWNKu8E4EjxBd1q5plCVdSpdmtKtysbUyatc0IVSq+OMNIGE2rcIPfA8MqzKKXUpLjJMNhTfCikgCbI1K5OcvahccfomvYm+BFxZFw5Z2rFB/2tLxMicAR4kuB4cEpV3HxtApR6Xpk02kMleKyWyjJcSZ2TcmC8uDMdqgmkelkNwNG36SALZM+ctLyoDpn1IVqRVbYbtLoQqW8ft12o/IuHUfCiMAR4osKUbk9Rlw8rQ6qkS7wj0VcxjUFmWhaermMzxk1rqEKw/OXVonGShT3O40qxHQ8qM4ZJXAWOdOwe7qym2bSt/JOBI4QX9RBZfcPU8AwTX1j6HqaxMXVhjPqKsOPTQ6qmaDsptjfDkBjGt7EOyzh4azpd1CdM0rg1KuQeFp5jFU4/LA/PUvEQQSOEG/sGaofDtRbOhjxBugb9SV4UXGif7LLOB1vVOeMOqiyPO3YCaTlQXUs3KxN7Gb6KLspD6kcpnTy4PSF8/3CU8TTz25E4Ajxp9DYdJZnppnbWG04LXoJIAfVjMguBXsmmh6iSutOryaRad6s7bxQAidvvAWje3oaef6U3RzyF2PRoCo//exGBI4Qf9Sms9gVHrqZJgInsuFIqe+M0bSI3cy2dqZXk0gljPeEm7WJ3Uyf/DpAwx4YoYDh9LlM+cZgpAOAJr2EcncGDlv6Hffp94mFxKMqqWZbu4A0qohRoYY3x8NTxCUHZ0aoJpHLM9OoSWQodKLyTi8l22mjIMuR2DUlE3ZXpHt6ndbBwJifwTF/ghcVB5TN+Oy5DJKdtt5iEThC/FGVVBXBcFw8TdzGatM5olzGlXkZiV1PsqE8OPMdhucvLW7jIx0Q9BLSrLTphVJ5dy4oYbwkIxwST4P9Jlx550jvfD8ROEL8UQdVvioVT4ubuG8URlRzQ72Eirz0dBmfF8pu6sJNItPBblR4atRVRgBb2h5U54Wym4jASQe7Ud7itkjlXXp6i2WHFeJPfj1pFxef4DIeSmOX8XmRb9zES8JNItPoJt5lU83axG5mTiR3ywiJp0UPJWU3R4PpXXkXU4HT39/P+vXrcbvduN1u1q9fz8DAwGmf9/v9fP7zn2fp0qVkZWVRUVHBHXfcQVtb26TnrrzySjRNm/R1++23x/KjCNHE7gK3USpep3XQPexlzBdI8KJijNpw+hzp21X0vFEHVa6nDSvBtLqJN6nKO0lMPweU3VSGjB5KadHNWHn+9qt8v3S1m5gKnA9+8IPs2rWLZ599lmeffZZdu3axfv360z4/NjbGjh07+NKXvsSOHTv49a9/zcGDB3nnO9950rN33XUX7e3tka//+Z//ieVHEaKNiosvcnYDaXCr6gu7jI2p2Ol6ozovcivB6sQS8lOu9dLUmwZNIpXdHPIZlXe1IoxnjhI4Bd4WIL1CVHtVa4F03W9ssXrh/fv38+yzz7JlyxYuueQSAH74wx+yZs0aGhoamD9//km/43a72bhx46Tvffe73+Xiiy+mqamJmpqayPczMzMpKyuL1fKFWFMwG469wtKMXvAYm86CstxEryp2hF3GgfBBlZ4bznlhsRhlvz0N1GmdvOYtoX/Mn9pVRcpuTlTeid3MGHWZcvgHcTNCU58rwQuKMaEgDDQB0BQqoSDLQY7LnuBFJYaYeXA2b96M2+2OiBuA1atX43a72bRp07RfZ3BwEE3TyMvLm/T9xx57jKKiIhYvXsz999/P8PBwtJYuxAN1q5pjCyeMprjbWN2o9nkKAcmlOGeU3SzLSJPhieEuxoFibBaNcneKH86xwJEF2cZluFbrpH3Qg8cfTPCiYshQGwR9hDQ77RSmbXgKYujB6ejooKSk5KTvl5SU0NHRMa3X8Hg8/P3f/z0f/OAHyc09cbv/0Ic+RH19PWVlZezZs4cNGzawe/fuk7w/YbxeL16vN/LfQ0NDM/w0QtRRpeKV4Rbqqe42DsfEvYbAkR4454gSOAtdPTBqhDZX1uQneFExwjMEY0rI6SVUF2Zis0pdyDlRMAtGOpjv6OZN72ya+8aYW5qT6FXFBiWKh1zlhMYtae31m/G/li9/+csnJfhO/dq2bRvAKfs16Lo+rT4Ofr+f22+/nVAoxEMPPTTpZ3fddRfXXHMNS5Ys4fbbb+dXv/oVL7zwAjt27Djlaz3wwAORRGe32011dfVMP7YQbVSzvwJvK6Cndg7OFJdxYZaDbGfM7hapjQo3zEqHUnEVnvLY8xkhk7o0PqjOm5M8f6lvN502le8nHpzp86lPfeqsFUt1dXW8+eabdHZ2nvSz7u5uSktLz/j7fr+fW2+9lWPHjvGnP/1pkvfmVFxwwQXY7XYOHTrEBRdccNLPN2zYwH333Rf576GhIRE5iUa1UHcERihkiOO9KezRGGqFkD/iMl4uB9W5ow6qsmC4IiaVDyrjJt7rCCemp/C/kVijhPHb9Dd42L6P4cb/B4tuSvCiYoTyFjeFVOVdGtvNjAVOUVERRUVFZ31uzZo1DA4O8vrrr3PxxRcDsHXrVgYHB1m7du1pfy8sbg4dOsSf//xnCgsLz/pee/fuxe/3U15efsqfO51OnE7nWV9HiCPhUvHBZuq0DnYN5OEPhrCnogu+7ygAg64KQuMW6tN4wzlvwsMTPa1ohFK7F054OCtG/kh9kdjNOaPsptZ7kFor9O26H25MUYGjhPGBSDg8fS9UMTtNFi5cyPXXX89dd93Fli1b2LJlC3fddRc333zzpAqqBQsW8NRTTwEQCAS45ZZb2LZtG4899hjBYJCOjg46Ojrw+XwAHDlyhK9+9ats27aNxsZGnnnmGd7//vezcuVKLr300lh9HCEWRBKNuwiGdNoGUnR4Yu8RANqt4bbpclCdM+5qsNiwhryU0k9jKntw+gy7ORiQ6fPnjdprwmT5+xK0kDigLlRvjhsCpy6N95uYXpcfe+wxli5dyrp161i3bh3Lli3jpz/96aRnGhoaGBwcBKClpYWnn36alpYWVqxYQXl5eeQrXHnlcDh48cUXue6665g/fz6f/vSnWbduHS+88AJWqzWWH0eINukSF1cbzjHlMq4rkoPqnLHaIM9oF1Fn6UztJpHKg/PWmFEiLh6c80CFqMIc06oStJAYo+sRuzkWMoazFmWncBuFsxDTTMeCggJ+9rOfnfGZiY266urqztq4q7q6mpdffjkq6xMSjKqkmmtXU8VTNdFYbTh7PEbbdDmozpOCWdB3lAWObrZ4jEqqlOyhpITxoUApNosmw1nPB5d70n8eDRQyN6RjtaTY4NLRHvAOoaPRrJcwpzC9h7OmYMKDkDSoSqoq3UgYbUrVnibqoNrrkRLxqJAOwxN9Y0ZyOtCol1JdICXi5811D0T+X5seoH0wBUPiaq8ZcZbixUFdml+m5F+MkDjUQVXkbQH01DyoQqFI0l+jXkZBlgN3Rnp2FY0aU4YnNvakoDAOD2e15dBPjuTfRIM198C7vweAg0Bq7jdK4HTZKwHSvqBBBI6QOMKl4sFRChlKzV44w20Q8BDSbLTqRdLLJBqEhyfqRsPQxlT0/KmDqtdZBWhpnSgaVaxGPooDf4oKHCMxvVE3WrGIB0cQEoXdZVTFYEwVb+pLweGJ6qAaclUQxJr2G05UUAIn32N4/o52p67AaVYl4iKMo0RY4GiB1Bzzoexmvzec75fediMCR0gskc60HYz5gnSPeM/yC0mG2nDarUaPpnR3GUeFvBrQLNiDYxQxlKIeHOMmfigQrrwTu4kKNqMfmgM/x1IxtKlaUpwYzprediMCR0gsqpJqsctIGG1KNbdxuEQ8aLiMa+WgOn9sTqNJJFCrddA5lIKl4uFeJqpEXEJUUSISogqknsCZVCJeTo7TRmFW+paIgwgcIdGoSqr5DlUqnmoCR92o9qquouLBiRIqTLXI1QNAY0+K2Y06qMIl4lX5UiIeFZQHx06A431jhEIpFBIf6wOv0VOuSS+hrigrrUvEQQSOkGjUQVWTqgmj6qDa6zHGm9SmeUw8aii7WapKxVPKbvweGGwB4LheSlV+hpSIRwurIXCcmh9fIERbKpWKq7CmlIifQP7VCIlFhaiK/cZU8ZRyG+t6JNTQqJdRmOUg1yUl4lEh38jdmmMzPH8pZTf9jYCO35ZFL7lyUEUTmxGyybAEgRSzG7XXdNrCJeJymRKBIySWCaXiRQyl1oYz3AGBcUKalVa9WA6qaBIuFQ8pz18q2Y06qHocUiIedZQHx6UZOVupaDfhEvF0TzAGEThCorE5J5SKt3OsZzR1SsWVy3jYWYYfmxxU0SRcKu41uv2mlDBWB1WrZlTeSYl4FFEeHDt+AI6mkt2ofL/9XiMcLhcqETiCGSg0Dqt6S6dRKj6cIqXikRJxY4p4uvekiCr5dQA4/IO4GUmtHJxIibjRy0Qq76KI8uDYdEPgpKIH561xQ+DIzDsROIIZUJVUyzKNhNGUuVVFpogbzdrEZRxFHJmQYwjHOq2DnhEfwx5/ghcVJSIHlVTeRR1VRWXRg1gJ0phKVZsTQlS5Lhv5mZLvJwJHSDwq3DDfnmIJo1OGbMqNKspEhm72ASlUKq7s5qC/BKtFo1JKxKOHyx3x4lRoPTT1jeEPhhK8qCgw1geeAcCovKuXEnFABI5gBlQlVbUqFU81gbNPYuKxQXXBXpZp9MI5lgphqoB3Qol4GVX5GdilRDx6WKwRYbzA1kEwpNPSnwKl4pEp4iV4cMpeo5B/OULiUSGqIl8KzRbSdeg1Np3jeilF2U6ynbYELyrFUAfVHGs3kCL5FP3HQQ/ht2bSjVsS02NB0RwAVmUZIfFjPSOJXE10CE8RtxlhWwmHG4jAERJPfu2k2UIpseGMdIF/FB0LzXqJVMLEgkipeBuQIp6/k6aIi91EncK5ACx0hEPiKRDa7J08RVwKGgxE4AiJZ8JsoTqtnaa+MYLJ3kI9PEXcWYYPu7iMY0GhcRMv8DSRMk0iIyXiaoq42E30KTIETh1hYZwCF6opU8TF82cgAkcwB+Fwg60Lf1CnNdnj4mrD6bCpKeJyUEWfwtmAhsM/SAHDqVEqruwmXCIuAicGKA9Osa8ZSJHkdNVaQErEJyMCRzAHKg9neaRUPMlvVWrDORYyXMZyo4oB9gzIM5pEztbaGBjzMzDmS/CizhNlN7vHjINqdlF2IleTmqiihkxPJ5l4Usrz16iXkZdpJy8zvaeIhxGBI5gDtenMS5XZQpEScTVkU3IpYoO6ja/MNBKNU8VujgRKcNgsUiIeCzILIFO1btDaaRscx+MPJnhR58FYH4z3A3BcL5EE4wmIwBHMgQpRVentQAocVL2HAdinYuKzimXTiQkqn2KpyxDGSR2mCvhgQIVN9DLqCjOxWqSXSUxQwnixoxNdh6a+JA5T9R0DYNRRxDguGbI5ARE4gjlQIaoCr1EqntQCJxSKVDUc1Ssod7vIdEiJeExQicazLeEeSkl8UPUfAz2I35pJF3nMkvBU7FCl4pGQeDK3plCXqQ41RXxWsdhNGBE4gjmYUCpezGByC5zhNvCPEdJsNOvFzJYNJ3YoD05FwGiOl9R203MIgC41RVy8fjFEeXDm29Q0+mT2/PUadnMkZBQ0yH5zAhE4gjmYVCreQetAEsfF1UHV76wggE0OqlhSNA+AXE8LdgLJ3exPHVSNGM3a5CYeQ5Qwrg4Z0+iT2m7UfvOWpwSQcPhEROAI5kGFqRY4u5M7Lq5cxs0W5TKWks3YkVMOjmwsepAarZNjPaPoepL2UOpReVs+o/JODqoYojw44R5KST3gV+03e30laJqUiE9EBI5gHlQl1bKMJI+Lqw2nwR8+qOQmHjM0LWI3cywdjHgDdA97E7yoc0R5cN4cNxLTpUQ8huTXgWbFHhyjlP7k9eBMyvcrpzIvA5fdmuBFmQcROIJ5UJVUc22dQBLnUyiX8e5xqaCKC+o2fkGWMXTzcHeS9lBSwvioXkFhlgN3pj3BC0phbA4j7w+YZWmna9jLiDeQ4EWdA0MtEBgnqNlo1kvkMjUFETiCeVAhqopQuFQ8WQ8qQ+AcDpbhsluocEsvk5ii8ikWOQxhfCQZPX9jfTCmPJd6mYjieKCE8VKn6r2VjHYTyferJIiV2WI3kxCBI5gHFWoo8DQDenK2UPePR3qZHNUrqC/KxiK9TGKLKhWvx0gYPdKVhMJYeW+GHSVGLxPJo4g9Shgvzwx7/oYTuZpzI5zvp0mJ+KkQgSOYhzyjVNwWHKeYgeRM/Os7Buh4bdn0kCs38XigKqmKvYawPJKMISp1E2+zGZWEclDFASWM51gMj/GRriTcb5TdHAgYw1lnizCeREwFTn9/P+vXr8ftduN2u1m/fj0DAwNn/J2PfOQjaJo26Wv16tWTnvF6vfzt3/4tRUVFZGVl8c53vpOWlpYYfhIhLtgc4DZmC9VpnfSMeBny+BO8qBmiwlOd9mpAkw0nHijPn9M/QB7DyZmcPiGsCVJ5FxeUB6dc9VBKSmGs7GaXGrI5u0SE8URiKnA++MEPsmvXLp599lmeffZZdu3axfr168/6e9dffz3t7e2Rr2eeeWbSz++9916eeuopHn/8cV577TVGRka4+eabCQaTtG+KcIJwJZVyGydduEHdqI7pRi8T2XDigCMLcpXnQ2undWCcMV+SJYz2TK6gEg9OHFA5ODmeNhz4OZxsew1EWgscDpaT5bBSkuNM8ILMRcz6x+/fv59nn32WLVu2cMkllwDwwx/+kDVr1tDQ0MD8+fNP+7tOp5OysrJT/mxwcJCHH36Yn/70p1xzzTUA/OxnP6O6upoXXniB6667LvofRogfBbPgyJ+MUvFRONw1wsqa/ESvavqEe1KEZ1BJqW98KJoDQy0sc3WxY3weR7tHWVLpTvSqpo+ymwOBMqwWjZoCmScUc7JLwJmL5h2iVuuksddBIBjCZk2SzA3fqFFFhVEiPqs4G02TfL+JxOx/yc2bN+N2uyPiBmD16tW43W42bdp0xt996aWXKCkpYd68edx11110dXVFfrZ9+3b8fj/r1q2LfK+iooIlS5ac9nW9Xi9DQ0OTvgSToiqpZqup4klX8qtu4nu8RlfResnBiQ/qNr4i07CbpAo3hIInpojr5dQUZOKwJckhm8xM6KE039aBP6jT3D+e4EXNAGUzHpubfnKlguoUxOxfUUdHByUlJSd9v6SkhI6OjtP+3g033MBjjz3Gn/70J/7zP/+TN954g7e//e14vd7I6zocDvLzJ9/qS0tLT/u6DzzwQCQPyO12U11dfR6fTIgpKvGvMqASRpMp8U/XIzHxo3oFpblOsp0yZDMuqHyKuVZjD0iqUvGBJgj6CFoctOlFkn8TT5QwXpVtlOgnVZhKXaY67JKYfjpmLHC+/OUvn5QEPPVr27ZtAKd0l+m6fkY32m233cZNN93EkiVLeMc73sEf//hHDh48yB/+8IczrutMr7thwwYGBwcjX83NzTP4xEJcKTYqYtxjTVgIJddNfKwXPIPoaBzTyyQ8FU8iQzdVqXgy2Y0KT/U4qghhkcq7eKLsZqE93EMp+ezmiC5DNk/HjK+Xn/rUp7j99tvP+ExdXR1vvvkmnZ2dJ/2su7ub0tLSab9feXk5tbW1HDpkqNWysjJ8Ph/9/f2TvDhdXV2sXbv2lK/hdDpxOiX5Kilw14DNhSXgoVrr4nivBW8giNOWBO3H1Y1qyFGG1+NgdokcVHFD3cTdnhasBJMrOV3ZTZP0Mok/ymNco7cBSVbUEA6Hy5DN0zJjgVNUVERRUdFZn1uzZg2Dg4O8/vrrXHzxxQBs3bqVwcHB0wqRU9Hb20tzczPl5YZKXbVqFXa7nY0bN3LrrbcC0N7ezp49e/jGN74x048jmA2LxTisOt9iqaOD494yGnvGmF+Wk+iVnR0Vnmq1qmnQ4sGJH7mVYMvAEhinWuviWI+dYEjHmgxNFpXd7Perg0pCVPFDeXCKvMeBJMv5U3azT4ZsnpaY5eAsXLiQ66+/nrvuuostW7awZcsW7rrrLm6++eZJFVQLFizgqaeeAmBkZIT777+fzZs309jYyEsvvcQ73vEOioqKeM973gOA2+3mzjvv5O/+7u948cUX2blzJx/+8IdZunRppKpKSHJUmOqi7G4gidzG6kZ1UDXdkhtVHLFYIrfx+dYOvIEQbQNJkjA6ZXbZHGktED9UUYPDN0g+QxzpGkmOafS6HikRP6pXyJDN0xDTVP3HHnuMpUuXsm7dOtatW8eyZcv46U9/OumZhoYGBgcHAbBarbz11lu8613vYt68efzVX/0V8+bNY/PmzeTknLjBf+tb3+Ld7343t956K5deeimZmZn87ne/w2qV/4FTgiJDAC+0GQmjSZP4p6b6vulR06Al1BBfigyBc2G26qGULMI4PGQzVE5BloPCbAmnxw1HZqS56CxLB0OeAD0jvgQvahqMdIJvmBAWjuulEtY8DTEt8SgoKOBnP/vZGZ+ZqJYzMjJ47rnnzvq6LpeL7373u3z3u9897zUKJkR5cGp0o8dD8ggc5cEJluO0WajIkyGbcUWNbFg4Yejmladvt2UOvMMwrEYF6OUsEO9N/CmcA4PNXJjdy/YhY78pNnvDPOX1G3SW4/PYJax5GqTZgmA+lAencLwR0JND4AR8EQ/O4VAFc0qykyP/I5VQicZ1qITRZPDgqINq1JbPENnMFYETf1Roc7kriXoo9YYT0418PwlrnhoROIL5KJwNmgW7f1gN3RwhFDJ5XLzvCOhBfNYsOihgXmkSJEWnGipEVexpApKkIqa7AYAWWw2ACJxEoBKNZ4eHbiaDwFF2s9dvCBzZb06NCBzBfNickF8HwEJbOx5/iFazJ4x2HwCgzV4DaHKjSgTqJu709ZHLSHI0+1N2sz9oHFRz5aCKP8puygJJFBJXdrPTY7RcEWF8akTgCOZEhanClVSmL99UN6qDIaOXidyoEoAzB3JU0zOtnZ4RLwNjJk8YVXazc0wOqoShPDg5Y81YCSbHNPouQ+AcDlVSlO0kP8uR4AWZExE4gjlRicZLnSph1Oy3KnWj2jEuB1VCUbfxVaqS6pDp7WY/AA16Fbkum/mTW1OR3CqwZ2EJ+anTOsw/jX68H0aMCtNDeiXzSmWvOR0icARzoipi6kmS1vvqJn4gWInTZqFapkEnBmU3KzIMz19Dx3AiV3NmfGPQbzSYOxSqZG5pjkyDTgQWCxQbHuMLMowLlam9ON0HARhylDBCpniLz4AIHMGcqBBVieoweqjTxAIn6I9UwxwKVTK7WCqoEkZk6KaRMHqo08QCp/cQoDNuc9NLrnj9EknJQgAuzjQ8IwfNbDfK63fcYvTvkXy/0yMCRzAnKkSV4ekihzEOdg6bt8No3zEI+fFbMmijUFzGiUTdxCt8RiVVg6kPqokVVJKYnlCUwFloM1oMJIPdSAXV2RGBI5gTlxuyjZEHc63tDHkCdA55E7yo06Dyb9odNehYpBImkRQbB1X22HGc+DhoZs9fl3ETPxA0EtPFbhKIspuqgOExPmjm0GakgsrYH+VCdXpE4AjmRXlxVucYCaMHOoYSuZrTM6WCSkINCSSnDFx5aHqI2ZY2+kZ99IyYVRgbdiOJ6SagZAEAuaPHsRMwd+6WqqA6FKqkOMdJXqZUUJ0OETiCeSk2Np0LMkweF1c3ql3qoBKXcQLRNChZBMDaHCPR2LS3cWU3DaFKshxWyt2uBC8ojcmtBGcuFj1AndZB26CHIY8/0as6Gc8gDBthtMN6pYjisyACRzAvKi4+h2YAGjpMGm5QN/H9wQqpoDIDJUkgjP0e6D8GGDfxOVJBlVg0LZK/dUmWUUllygR1VUE1bC9iiCy5TJ0FETiCeSlZDECZx5jx1NBpwhBVKAg9xqZzUK+SCiozoDw48zUljM2Yh9N7CPQQHmsO3eTJTdwMKI/xhaqSypQXqnAFlVWN9pD8mzMiAkcwL8qD4xrvJJcRDnWOEDTbTKr+Rgh68VuctOrFsuGYAWU3Zd5GwKQeHOX1a7XXApoIHDOghPECq9F7y8x2s08qqKaFCBzBvLhywW30elhqb8UbCNHUN5bgRU1B5VF02GsIYZENxwyoipissRYy8ZizxcCUGVQLy3MTuRoBIqHNCp9RSWXKRGOZQTUjROAI5kbdqi7L7QKgwWyVVGrDOaRLBZVpyCqErBLAuI0PewJ0DHkSvKgphA8qlZi+oEyEccJRwjhnrAkHfhrMKIylgmpGiMARzI0KNyx3qAZcZouLq14m4YNKbuImQdnNmhyTjmxQB9XBUCUFWQ6ZQWUGcsrA5UbTg8y2tKsWAyYa1uodhiFj4vkhvUr630wDETiCuSk1Eo1nhYzOtKaLi3fuBWBPsIZsp43KvIwEL0gAIp6/C1zhkQ0mEsa+MegzEucPhKpZUCYVVKZA0yJenEtzDI+xqfYbdZkathUySDYLy+QydTZE4AjmRh1URWOHAd1czf4C3kgF1YFQDQvKcrBIBZU5UPkUkRYDZjqoug+AHmLUlk83eSyQg8o8TGkxYCrPX+ceAI5Y6wDxFk8HETiCuSmaC5oVm3+YMvpo7B3D4w8melUGPQchFGDcmkM7BSwolzwK06CEcannKGC2g8rw+h2zGhVUYjcmQtnNPM0IBZnKg6PsZofXyPcTgXN2ROAI5sbmjEyIvsDVTjCkc7R7NMGLUqgN57itDtBkwzETqqeJy9NFPkM0dA4TCIYSvCiFsptdvioACTWYCRUSr/AeBuCAmYRxh+HB2e2rwmaR4azTQQSOYH5UwujaHKPDqGka/imX8W6/OqhE4JgHVy7k1wOw0tGCLxDiaI9ZhLFhN7t8lVg0adZmKkqXAJA51kYuIxzsHCZkht5buh4Rxgf0GuaUZOOwyfF9NuQvJJgf1dF4ic1wGx9oN8mtSm04O72VaBrMlx445qJsKQBX5Br5FPvaTCCMdT0icPaHaqgrysJltyZ4UUKEjDzIM7oEL7c3M+YLctwMvbcGmsA3TFCzcUSvkMvUNBGBI5gf5Tau8xuVJ3vNcFDBiRtVqIbagkyynLYEL0iYRNkywDioAPa1m8BuhtthvJ+QZuWwXinhKTOi7CYsjPe2DSZyNQZKFLfbawlgY6HkbU0LETiC+SlfDoB79BhOfOxtG0x8A66RbhjpREfjoF4llTBmRHlwwsLYFB4cJYq77NV4cUiDPzOi7Galw/AYm8lu9oWMzu7iwZkeInAE85NbAZmFaHqQhdYW+sf8tA8muDNtl7Hh9DgqGMMlG44ZUQdVWBjvax9KvDBWN/EDuhEGmS8Cx3wou6kPGBV4pvAYK7t5wyMVVDNBBI5gfjQt4ja+Ktdo3JbwTUfdqA7qtQBS6mtGJgjjBdZW+kZ9dA55E7smZTfbxssBWFzpTuRqhFOhBE7e6FHsBBK/10Ckgmp/qIaibCdF2dL5ejqIwBGSg3JD4FzkMvIpEh4XVwfVdo8xLHGR3KjMh6ZNSDQ2hPG+dnPYzd5QDQVZDircrsSuRzgZdzW43FhCfuZaWukZ8dI1nECPsW8U+gxv0oFQjeTfzAAROEJyoPJw5gRN4jbueMtYR7CKHJeNqnwZ0WBKlMC5yGnkU+xPZAXehM7X+0M1LK7IlRENZmSCx/hEonEC95uuA4DOsK2AHtxymZoBInCE5KDMEDhFo4ewEkxs4l/AG5kLs1evY2mlWw4qs6IOqrl6I5DghNGufRAKMGbNoYMClkh4yrwoYXxxRiuQYLvpeBOAI5oRDhe7mT4icITkoGAWOLKxBL3M1tpoHRinfzRBk3679kHIz5g1hxa9mKWy4ZgXdVAVjR5CI5TYUvG2XQA0WGYDmtiNmVF2M88Mwrh9FwCve40KKrGb6RNTgdPf38/69etxu9243W7Wr1/PwMDAGX9H07RTfv37v/975Jkrr7zypJ/ffvvtsfwoQqKxWCKbztty2oAE9jVRB9XB8EFVJRuOaSmcC1YntsAotVonx3pGGfb4E7MWdVC94TEqqJZUiN2YFrXXlI42AHpic/7UfrMrUEeOy0ZtYWbi1pJkxFTgfPCDH2TXrl08++yzPPvss+zatYv169ef8Xfa29snfT3yyCNomsb73ve+Sc/dddddk577n//5n1h+FMEMqHDDauU2TtimE75RqYNKblQmxmqDMqP9/tuyDbt5qzVBdhM+qIJ15LpsVBdI3pZpKV5gCGP/MHVaB429Y4x4A/FfR8BneIyBt/R6llVJOHwmxKz16v79+3n22WfZsmULl1xyCQA//OEPWbNmDQ0NDcyfP/+Uv1dWVjbpv3/7299y1VVXMWvWrEnfz8zMPOlZIcVRlVQLOAYkMPFvykFVUyA3KlNTuQpat3NFVhM/Gb6QN1sGWTu7KL5rmHBQvanPYonkbZkbq93Yb1re4IqsZhpHytnbOsglswrju46ufRD0MWbNoVkv4Ua5TM2ImHlwNm/ejNvtjogbgNWrV+N2u9m0adO0XqOzs5M//OEP3HnnnSf97LHHHqOoqIjFixdz//33Mzx8+uoIr9fL0NDQpC8hCVGVVGVjDWiEeKslATfxKTeqpXKjMj+VqwBYpBsTot9sGYj/GiYcVJK3lSRUXADA27KM1hS7E2E3ylscDocvq8yL/xqSmJh5cDo6OigpKTnp+yUlJXR0dEzrNf73f/+XnJwc3vve9076/oc+9CHq6+spKytjz549bNiwgd27d7Nx48ZTvs4DDzzAV77ylZl/CMFcFC8AWwY2/wiztHaO9FgYHPPjzrTHbw1yo0o+lMApGTmAjQC7mxMgjKccVNLgLwmoNAROWBgnxG7adgKwVYXDl0m+34yYsQfny1/+8mkTgcNf27ZtAzjlzVbX9WnfeB955BE+9KEP4XJNboZ11113cc0117BkyRJuv/12fvWrX/HCCy+wY8eOU77Ohg0bGBwcjHw1NzfP8FMLpsBqh4qVAFyb0wTArnjfqiIH1SzkRpUkFMwGpxtr0MM8SwutA+P0jMS5o7EKa77ulbytpEF5cEpGG7ASZFfzQPzXoOxmd7AOd4Zd+m3NkBkLnE996lPs37//jF9LliyhrKyMzs7Ok36/u7ub0tLSs77Pq6++SkNDAx/72MfO+uwFF1yA3W7n0KFDp/y50+kkNzd30peQpFQZt/HLMxsB2B3vTad9NyAJxkmFxQKVShjnGg3/4h6mUsJ4V6COHKeNWsnbMj+Fc8CZizXoYb4SxnHtaCwJxufNjENURUVFFBWdPUFvzZo1DA4O8vrrr3PxxRcDsHXrVgYHB1m7du1Zf//hhx9m1apVLF++/KzP7t27F7/fT3l5+dk/gJDcVF0EwIJAA0D8b1WRG1U97gy7VMIkC5Wr4OhLrHEd59tcxu7mQd6+4OwXragQ8EVGNLyl17OiJg+LRQ4q02OxQMUKOPYK17hb2ddfy5vNg1yzKE7jNaaEw98hl6kZE7Mk44ULF3L99ddz1113sWXLFrZs2cJdd93FzTffPKmCasGCBTz11FOTfndoaIj/+7//O6X35siRI3z1q19l27ZtNDY28swzz/D+97+flStXcumll8bq4whmQQmcgtHDZOBhV/NA/CZEB/2Rg2qPXic3qmRC5eHMCxijEuLqwenebxxUFuOgWlmdF7/3Fs4PFaZa6zoOxPlCpbx+DZo0hjxXYtoH57HHHmPp0qWsW7eOdevWsWzZMn76059OeqahoYHBwcnJW48//ji6rvOBD3zgpNd0OBy8+OKLXHfddcyfP59Pf/rTrFu3jhdeeAGr1RrLjyOYgdwKyKlA00NcYDtG36iP5r7x+Lx35x4IehmzZHNcL2VlTX583lc4f5TAyR89QiYedrcMxk8Yq0TR/Vo9oIndJBPKbuYrj3FcK6kiCcZGB+MVNXnxe+8UIWZVVAAFBQX87Gc/O+Mzp9pkPv7xj/Pxj3/8lM9XV1fz8ssvR2V9QpJSdSHsf5p1uc38pW8hu1oGqIlHd8/mNwB4S5sHaKyqlYMqacgpg9xKtKFWVtga2TS6gJb+carjkQuj7GaT1+jltUI8OMlDtZFekTd8iGzG2NU8QCikxyfE2GIU6+wMzabC7aLcLeHwmSKzqITkQ4WpLrIbk8V3NQ3E531bXgfgLx45qJISdRtfl2tUUe6MV7hB2c2O0FzqCjPJz3LE532F8yenDPJq0dC5xH6EYU+AY72jsX9fz1AkwXhHaC4XyGXqnBCBIyQfVRcCMMuzD9DZ1dwfn/dtMW7iO/U5zC3Jxp0Rx/47wvmjbuOr7Ua15fbGvti/51gf9Bh5PztDcyQ8lYzUrAbgulyVhxOPC1XrdtBD9FhL6SZfvMXniAgcIfkoXwGaFZe3h0p62NM2hDcQjO17jnRDfyM6GrtCc7hADqrko2YNALPG30IjxBuNcRDGrdsBaLdVMUAOKyWPIvmoNrrxX2Q1hOq243GwG3WZej04B0AEzjkiAkdIPhyZkblUV2YcxRcIsSfWAxRVmKHZVsMwmbLhJCPly8GeicM3yBytjQMdQ7GfLN5s2M3rgdkArKwWu0k6lMCpHt2HlSBvxMPzp+xmq38OLruFheXSu+1cEIEjJCe1RkuA63OOALD1WIw3HXWj2uoz8m8uqM2L7fsJ0cdqj4Q3r8s+SkiHnbEONyhh/Lp/NtlOGwvLc2L7fkL0KVkIzlxswTEWaE0c7hqhb9QXu/cLhSblbS2rysNulaP6XJC/mpCcKIGzNLAHgNdjLXBUJcwbwTm4M+zMKsqO7fsJsUGFqa7KMITxtljexkNBaDFCVDtCc1lVm49NDqrkw2KNFDbc6DbycGLqxek9BJ5BfJqT/XqNhMPPA/nXJiQnNasBjbyxRooYZFtjP8FQjPqaBLyRXIodoblcUl8gnWiTFSVwFvgMYRzTPJyufeAbxqNl0KBXc3F9QezeS4gtym7e5jTycGJ6oVLhqX3abALYuETs5pwRgSMkJ5kFULoYgCucBxnxBtjfPhSb92rdAYFxhix5HNYrWTO7MDbvI8SeqotAs5LlaaeCHnY29+MLhGLzXo1/AWCHPp8QFlbPkoMqaam/HIB547tUgnoMBc5xw27+4puD1aJxkQicc0YEjpC8qDDVjbkxzsM5/hoAm4PzAY3Vs0TgJC3ObCPZGLg64yAefyh2YxsaXwXgVf8CXHYLS2XyfPJScQHYs3D6BligNbO3bYhRbyD676Pr0Kj2m9Billa6yXbGtB9vSiMCR0he6gyBsyJkNMTaerQ3Nu+jNpzXAgvJy7Qzv1QSRZOaWVcAcHO20X7/tcM90X+PUChyE98SWsgFNfk4bLLdJi02B9QaQ6JvyD5IMKTHply8vxEGmwlgY3torniLzxP5FyckLzXGhlM4epgiBtlytDf6eTgBHzRtBWBLaJHk36QCs64EYKlvF6Cz6XAMhHHXPhjvx6u5eEuv55J6OaiSnvq3AXCNSwnjQ93Rfw91mdqrzWEcF2vEW3xeiMARkpfsYihbCsC1rr0MeQLRH4bXFs6/cXNIr5QNJxWoXg02F5nebuZqrexo6o9+uEEdVNv0+QSwyU08FVACZ+74bqwEefVQDDx/ym5e8S/AbtW4sE4qqM4HEThCcjP7agDenXMAgFcPRnnTUXkUkfwbOaiSH7srUhVzc/YBAiE9+lUxym5e8y8kx2mTDsapQNlScOVhD4yyzHKUAx3DdA15ovf6uh6xmy2hhSyvyiPTIfk354MIHCG5mXMNAMu9O9AI8Wq03cbHXgFgU2AhZbkuyb9JFWZfBcA6lyGMo5qHEwpOyr+5dE6RNGpLBSzWSDXVLW6jXDyqdtN/DIZaVf7NPC6dUxS9105T5F+dkNxUXwKObFy+PhZpTexsHmAoWu33vcNwfDMAr4SWceX8YjRN8m9SApWHM3d8F3YCvBbNcEPrDhjvZ1TL4i29nrfNK47eawuJZe46AN5u2QkQ3TDV4RcB2KnPxYOTty8oid5rpykicITkxuaAOuNW9e6c/QRDUUwaPfYKhPy0aqUc08u4cr5sOClD6VLIKsYWGGO1ZT8NncO09I9F57UPbwTgpcASAth42zy5iacMSuCUj+6jiEFePdRDKFqFDYcMu3kxsJyibAdLK93Red00RgSOkPzMMfJwrnW8BcDLB7ui87pqw3nBvwy71cKlcyT/JmWwWGDe9QB8MG8vAC/s64zOax96HoA/h1YwuziLqvzM6LyukHhyyqB8BQDXOXbTM+LlrWgM+vWPR8Lhfw6t4Ip5JVKtGQVE4AjJj7pV1Y6+SQFDbNzXef7l4roOh18AjA3noroCclz2812pYCYW3ATA5cHXAZ0X9kdBGI90QZsRvng5uJwr5onXL+VQwviWHEMYP7e34/xfs/EvEBinSyukQa+W8FSUEIEjJD/5tVC+HE0P8S7XDnpGfGw/3yZc3Q0w2IwPO1tCi7hyvuRRpByzrgR7JtneDhZrx9lytJfB8fPM31J5FPuop5s8rltcev7rFMzFvOsAWOrdjp1AdASO8vq94F+O1WLhsrkS1owGInCE1GDhOwG4LWsXAH/c035+r3foOcCogvHgZN2isvN7PcF82DNg9tsBuDXnTQIhnZcaztOLo+zmhcByCrMcXFgnc4RSjvIVkF2KLTDGlba3ONI9yuGu4XN/PV2fFNa8uK4Ad4Z4i6OBCBwhNVj0LgDmje0glxGe29OBrp9HmGrfbwHYGLyAxRW51BVlRWOVgtmYfyMAN9i2AfD8+eTh+McjeVt/Cl7AusWlWCWPIvWwWGDRuwH4aO4OAJ7bex5207UP+o/hw85fQku4aVl5FBYpgAgcIVUomgvFC7HoAW5w7KZt0MObLeeY/Nd/HFq3E8LCH4OXcONS2XBSlvk3gMVGydhh5motvLCvk+FzbTNw6HnwjdBGMbv02axbLF6/lGXp+wG4yLsJF97z8xi/9SsA/hRcgUdzccMSsZtoIQJHSB2UF+eO7DcA+O2utnN7nb1PAUZ4qgc3N4nASV0yCyJJ6h/N3oo3EDr32/ieXwPwdOASCrKcXCaN2lKXqgshrxZ7cJx1tp3saR3iUOc5hKl0HfY8CcDvgmtYO7uIwmxnlBebvojAEVKHZbcCsGh8G6X08ZtdrfgCoZm/jtpwfh9czYrqPAlPpTrKbt5heQ2NEL/d1Trz1/AOw0Ej/+b3wdW8c3mFdC9OZTQNlrwPgI/mGuHNX+1omfnrtO6AgeOM4+JPoRW8c3lFNFeZ9si/QCF1KJwNNWvR9BB3ZG6mb9THnw7M8Dbetgs63sSHjT8GL+K2i6pjslTBRMy7AZy55Hg7WWvZy18O98y86d+eX0NgnKN6OXv0em5ZVRWbtQrmQYWplo+/QSGDPLWjlUBwhheqnT8F4LngBVgcWZJ/E2VE4AipxcoPA/BB+8tohHj8jeaZ/f6O/wXg2eBFeOz53CwbTupjd0W8OPfmvkJIh8e2Ns3sNbY/CsAvAlcxvzSXxRW5UV6kYDpKF0HlhVh0Px/JeIWuYS8vHphBFZ53BN76PwCeCF7FO1dUkOWU4ZrRRASOkFosehc43eR7W7jaupOXGrqnX8LpG40k/P0i+HZuXlYuzf3ShYvuAuBCz2Yq6OHx15vw+IPT+9323dC2Az82ngy+jb9aWyczy9KFiz4GwB32P2ElyMOvHZv+7+75FfhGOKaXsTm0iNsuqonRItMXEThCauHMhgs/AsD/yzE6EU9709nxU/AO0RgqZUtoIR+7fFaMFimYjpIFUHc5GiHuyfoz/WN+frNzmrk4W74PwHPBCwllFvKelZUxXKhgKha/BzILcfs6udG6jdeP9fHWdKo3QyHY+gMAfh54OxfU5LO8SmZPRRsROELqcfHfgMXGfM9uVmiHeXJHK+2D42f+nYAPNn0XgB8Gb+LK+aXML8uJw2IF07DmkwDcxrMUMMR3/3T47Enq/cfR33wCgB8GbuQDF9eQ4bDGeqWCWbC7Il6cDdlPoxHiv/586Oy/d/BZ6NrLiJ7BL4NX8okr54jXLwaIwBFSD3clLLsdgH/N/j98gSD/8dzBM//Om0/AUAtdeh6/Cr6NT1w5Jw4LFUzFvOuhfAX24Dj3Zv6R1oFxnth2lhyuTd9B04O8GlzCEccC7hKvX/qx+hPgdFPhPcbN1q08t7eTbY19p39e1+HV/wDgJ8FrKS0t42qZPRUTROAIqclVG8DmYrH/La61bOfJHS282TJw6mfH+9Ff/Apg3MKvWFTNxfXSYj/t0DS46gsAfIg/Uq+1883nG+ge9p76+a4D6Cq5+KHgu/ibt82iIMsRp8UKpiEjH9bcA8BXM/+PTDz88x/2n76ias+T0Lqdcd3Bw4Eb2HDDQpkcHiNiKnD+9V//lbVr15KZmUleXt60fkfXdb785S9TUVFBRkYGV155JXv37p30jNfr5W//9m8pKioiKyuLd77znbS0nEMPAiF1cVdFQg7/nvkT8hjm3id2MeoNnPzsi19FG+3mcKiCn3M9X7hpYZwXK5iGudfCrKuwhnx8J+vHDIx5+dJv9pw89iMYgN99Gi0U4PngKo7nrOKvL6tPzJqFxLPmU+CuId/fweedT7K7eYCHXjpy8nOjPejP/QMADwXeyfIFc7lKvDcxI6YCx+fz8f73v59PfOIT0/6db3zjG3zzm9/kv/7rv3jjjTcoKyvj2muvZXj4RCXMvffey1NPPcXjjz/Oa6+9xsjICDfffDPB4DSrHoT04PK/g8K55AV6+G7mD2nsHub//Wr35JvVnidh2yMAfCnwUT557WJqC6WxX9qiafCOb4M9i6WBPdxre4pn93acfFi9+BVo3sqQnsFX/HfwwPuWSYlvOuPMhpu/CcAd2jNcY9nOt188xJ8nlo0H/ei/vgttpJNDoUp+bns3X37H4gQtOD3Q9POaSDg9Hn30Ue69914GBgbO+Jyu61RUVHDvvffy+c9/HjC8NaWlpXz961/nb/7mbxgcHKS4uJif/vSn3HbbbQC0tbVRXV3NM888w3XXXXfW9QwNDeF2uxkcHCQ3V/pVpDTtu+FH10DQx2+Dl/J5/8e4eF4V/3jzIqpbf4/t6U9i1QN8L/AO3pjzGX50x4XiLhaMirqnPwXAN/y38r3gO/nQ6jo+feUssrf8B5lbjMPsb32fov6qv+K+a+clcrWCWfjD38EbP8KvOfiU9x7+rK3m/uvm8YEVBVh/8wkyj/4Rj27n3f5/5t4PvofrZe7UjJnJ+W2qK8exY8fo6Ohg3bp1ke85nU6uuOIKNm3axN/8zd+wfft2/H7/pGcqKipYsmQJmzZtOqXA8Xq9eL0n4uhDQ0Ox/SCCeShfDu/7EfzfR3mX9S+stuzjlaNL6f+vDuZYjMTj3wdXs7X+k3zvgxeIuBEMLlgPA8fhlX/nc/Zf8k7rZnZvm83wjgZKLMZgxa/7b6d07Ye49+q5CV6sYBqu/zcYbMV+8I/8j+NBtoQW0rqxCM+Lb1KsDeLTrXwqcC9//d6bRdzEAVMJnI6ODgBKS0snfb+0tJTjx49HnnE4HOTn55/0TPj3p/LAAw/wla98JQYrFpKCRe+C9U/Bbz5B6VAr77e9AkBAt/Az23sJXvV5Hr58LlYRN8JE3v5FyK2E57/EAl8zCyxGRdWAnsWPsj7O8hv/huuXSKdrYQJWO9z2U3jxK+ib/5vVlv2RHzXrxTxSsoFPvfN9rKjOS9wa04gZC5wvf/nLZxULb7zxBhdeeOE5L2pqPwBd18/aI+BMz2zYsIH77rsv8t9DQ0NUV8uMobRi1hXw6Z1G/4nuBvyufMbq1vGR0tpEr0wwMxd+1BDIDX+EoVY8WZXY5l7P/e7CRK9MMCtWO6z7F7SLP24MYB3vZzRvPsXz1/FProxEry6tmLHA+dSnPsXtt99+xmfq6urOaTFlZYbLrqOjg/LyEzejrq6uiFenrKwMn89Hf3//JC9OV1cXa9euPeXrOp1OnE4ZQZ/22JzGYQXYAekbKkyLzAJY+SEAXAleipBE5NXAxcYIEClbSAwzFjhFRUUUFRXFYi3U19dTVlbGxo0bWblyJWBUYr388st8/etfB2DVqlXY7XY2btzIrbcaA/La29vZs2cP3/jGN2KyLkEQBEEQkouY5uA0NTXR19dHU1MTwWCQXbt2ATBnzhyys7MBWLBgAQ888ADvec970DSNe++9l6997WvMnTuXuXPn8rWvfY3MzEw++MEPAuB2u7nzzjv5u7/7OwoLCykoKOD+++9n6dKlXHPNNbH8OIIgCIIgJAkxFTj/+I//yP/+7/9G/jvslfnzn//MlVdeCUBDQwODgyeGk33uc59jfHyce+65h/7+fi655BKef/55cnJOzAX61re+hc1m49Zbb2V8fJyrr76aRx99FKtVZsAIgiAIghCnPjhmQ/rgCIIgCELyMZPzW2ZRCYIgCIKQcojAEQRBEAQh5RCBIwiCIAhCyiECRxAEQRCElEMEjiAIgiAIKYcIHEEQBEEQUg4ROIIgCIIgpBwicARBEARBSDlE4AiCIAiCkHLEdFSDWQk3bx4aGkrwSgRBEARBmC7hc3s6QxjSUuAMDw8DUF1dneCVCIIgCIIwU4aHh3G73Wd8Ji1nUYVCIdra2sjJyUHTtKi+9tDQENXV1TQ3N8ucqxgif+f4IH/n+CF/6/ggf+f4EKu/s67rDA8PU1FRgcVy5iybtPTgWCwWqqqqYvoeubm58o8nDsjfOT7I3zl+yN86PsjfOT7E4u98Ns9NGEkyFgRBEAQh5RCBIwiCIAhCyiECJ8o4nU7+6Z/+CafTmeilpDTyd44P8neOH/K3jg/yd44PZvg7p2WSsSAIgiAIqY14cARBEARBSDlE4AiCIAiCkHKIwBEEQRAEIeUQgSMIgiAIQsohAieKPPTQQ9TX1+NyuVi1ahWvvvpqopeUVDzwwANcdNFF5OTkUFJSwrvf/W4aGhomPaPrOl/+8pepqKggIyODK6+8kr179056xuv18rd/+7cUFRWRlZXFO9/5TlpaWuL5UZKKBx54AE3TuPfeeyPfk79zdGhtbeXDH/4whYWFZGZmsmLFCrZv3x75ufydo0MgEOCLX/wi9fX1ZGRkMGvWLL761a8SCoUiz8jfeua88sorvOMd76CiogJN0/jNb34z6efR+pv29/ezfv163G43breb9evXMzAwcP4fQBeiwuOPP67b7Xb9hz/8ob5v3z79M5/5jJ6VlaUfP3480UtLGq677jr9xz/+sb5nzx59165d+k033aTX1NToIyMjkWf+7d/+Tc/JydGffPJJ/a233tJvu+02vby8XB8aGoo8c/fdd+uVlZX6xo0b9R07duhXXXWVvnz5cj0QCCTiY5ma119/Xa+rq9OXLVumf+Yzn4l8X/7O509fX59eW1urf+QjH9G3bt2qHzt2TH/hhRf0w4cPR56Rv3N0+Jd/+Re9sLBQ//3vf68fO3ZM/7//+z89Oztbf/DBByPPyN965jzzzDP6F77wBf3JJ5/UAf2pp56a9PNo/U2vv/56fcmSJfqmTZv0TZs26UuWLNFvvvnm816/CJwocfHFF+t33333pO8tWLBA//u///sErSj56erq0gH95Zdf1nVd10OhkF5WVqb/27/9W+QZj8eju91u/fvf/76u67o+MDCg2+12/fHHH48809raqlssFv3ZZ5+N7wcwOcPDw/rcuXP1jRs36ldccUVE4MjfOTp8/vOf1y+77LLT/lz+ztHjpptu0v/6r/960vfe+9736h/+8Id1XZe/dTSYKnCi9Tfdt2+fDuhbtmyJPLN582Yd0A8cOHBea5YQVRTw+Xxs376ddevWTfr+unXr2LRpU4JWlfwMDg4CUFBQAMCxY8fo6OiY9Hd2Op1cccUVkb/z9u3b8fv9k56pqKhgyZIl8r/FFD75yU9y0003cc0110z6vvydo8PTTz/NhRdeyPvf/35KSkpYuXIlP/zhDyM/l79z9Ljssst48cUXOXjwIAC7d+/mtdde48YbbwTkbx0LovU33bx5M263m0suuSTyzOrVq3G73ef9d0/LYZvRpqenh2AwSGlp6aTvl5aW0tHRkaBVJTe6rnPfffdx2WWXsWTJEoDI3/JUf+fjx49HnnE4HOTn55/0jPxvcYLHH3+cHTt28MYbb5z0M/k7R4ejR4/yve99j/vuu49/+Id/4PXXX+fTn/40TqeTO+64Q/7OUeTzn/88g4ODLFiwAKvVSjAY5F//9V/5wAc+AIhNx4Jo/U07OjooKSk56fX/fzv385LKAsUB/HSd1AoRQmIqSXTVL4PSTQUtatOiP6CQmnVgaIsiaNGqH6sWQQRBtLGgjYvaZWRCIAmlZLWoTdhCMkIsMHLheZv35t65du/tPue9e5v7/cAsnDkM43cGPeicqaurKzt3NDgqqqioULxm5pJ18D5er5fOz8/p+Pi4ZNu/yRnn4rO7uzvy+Xy0v79PRqPxm3XIuTzFYpHcbjctLCwQEVFnZyddXl7S2toajY2NyXXIuXw7OzsUCARoe3ub2traKJFIkN/vp4aGBpIkSa5D1upTI9O36tXIHX9RqcBisZBOpyvpNjOZTEl3Cz82MTFBu7u7FA6HyWq1yutFUSQi+m7OoihSoVCgbDb7zZo/3enpKWUyGXK5XCQIAgmCQJFIhFZWVkgQBDkn5Fye+vp6am1tVaxraWmhVCpFRLie1TQ1NUUzMzM0PDxMTqeTRkdHaXJykhYXF4kIWf8X1MpUFEW6v78v2f/Dw0PZuaPBUYFeryeXy0WhUEixPhQKUU9Pzy86qo+Hmcnr9VIwGKTDw0Oy2+2K7Xa7nURRVORcKBQoEonIObtcLqqsrFTUpNNpuri4wLn428DAACWTSUokEvLidrvJ4/FQIpEgh8OBnFXQ29tb8piD6+trstlsRITrWU35fJ4+fVJ+nel0OnlMHFmrT61Mu7u7KZfLUSwWk2tOTk4ol8uVn3tZtyiD7J8x8Y2NDb66umK/3881NTV8e3v7qw/twxgfH2ez2cxHR0ecTqflJZ/PyzVLS0tsNps5GAxyMpnkkZGRN8cSrVYrHxwc8NnZGff39//Ro57v8eUUFTNyVkMsFmNBEHh+fp5vbm54a2uLq6urORAIyDXIWR2SJHFjY6M8Jh4MBtlisfD09LRcg6x/3vPzM8fjcY7H40xEvLy8zPF4XH78iVqZDg4OckdHB0ejUY5Go+x0OjEm/rtZXV1lm83Ger2eu7q65PFmeB8ienPZ3NyUa4rFIs/NzbEoimwwGLivr4+TyaRiPy8vL+z1erm2tparqqp4aGiIU6nU//xuPpavGxzkrI69vT1ub29ng8HAzc3NvL6+rtiOnNXx9PTEPp+Pm5qa2Gg0ssPh4NnZWX59fZVrkPXPC4fDb34mS5LEzOpl+vj4yB6Ph00mE5tMJvZ4PJzNZss+/gpm5vJ+AwIAAAD4veAeHAAAANAcNDgAAACgOWhwAAAAQHPQ4AAAAIDmoMEBAAAAzUGDAwAAAJqDBgcAAAA0Bw0OAAAAaA4aHAAAANAcNDgAAACgOWhwAAAAQHPQ4AAAAIDm/AWTjZmd4mnOXwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Start importing packages\n", "import pandas as pd\n", @@ -956,7 +1082,7 @@ "Tp = 800 \n", "\n", "t=np.arange(0,N)\n", - "x=np.sin(0.02*t)+2*np.random.rand(N)\n", + "x=np.sin(0.02*t)#+2*np.random.rand(N)\n", "df = pd.DataFrame(x)\n", "df.head()\n", "\n", @@ -994,9 +1120,7 @@ { "cell_type": "markdown", "id": "fcbca2f7", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### RNNs\n", "\n", @@ -1014,9 +1138,7 @@ { "cell_type": "markdown", "id": "1c5b70a2", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Basic layout\n", "\n", @@ -1030,9 +1152,7 @@ { "cell_type": "markdown", "id": "29c129fe", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### We need to specify the initial activity state of all the hidden and output units\n", "\n", @@ -1052,9 +1172,7 @@ { "cell_type": "markdown", "id": "c2bc1aa3", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### We can specify inputs in several ways\n", "\n", @@ -1070,9 +1188,7 @@ { "cell_type": "markdown", "id": "01ef7e17", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### We can specify targets in several ways\n", "\n", @@ -1116,9 +1232,7 @@ { "cell_type": "markdown", "id": "8dd26bf6", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### Backpropagation through time\n", "\n", @@ -1137,9 +1251,7 @@ { "cell_type": "markdown", "id": "3b42d5ef", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### The backward pass is linear\n", "\n", @@ -1198,9 +1310,7 @@ { "cell_type": "markdown", "id": "2f8de715", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## The problem of exploding or vanishing gradients\n", "* What happens to the magnitude of the gradients as we backpropagate through many layers?\n", @@ -1223,9 +1333,7 @@ { "cell_type": "markdown", "id": "9998cb2c", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Four effective ways to learn an RNN\n", "1. Long Short Term Memory Make the RNN out of little modules that are designed to remember values for a long time.\n", @@ -1242,9 +1350,7 @@ { "cell_type": "markdown", "id": "45dfbeff", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### Long Short Term Memory (LSTM)\n", "\n", @@ -1266,9 +1372,7 @@ { "cell_type": "markdown", "id": "141b8f50", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "### Implementing a memory cell in a neural network\n", "\n", @@ -1348,9 +1452,7 @@ { "cell_type": "markdown", "id": "fbadc1e0", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## An extrapolation example\n", "\n", @@ -1362,12 +1464,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 3, "id": "9365f92f", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "\n", @@ -1403,9 +1502,7 @@ { "cell_type": "markdown", "id": "55c2aa23", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Formatting the Data\n", "\n", @@ -1445,12 +1542,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 4, "id": "b57a3099", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "# FORMAT_DATA\n", @@ -1530,22 +1624,393 @@ { "cell_type": "markdown", "id": "0b519f6c", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Predicting New Points With A Trained Recurrent Neural Network" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "id": "82db8594", - "metadata": { - "collapsed": false, - "editable": true - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " input_1 (InputLayer) [(None, 2, 1)] 0 \n", + " \n", + " RNN (SimpleRNN) (None, 200) 40400 \n", + " \n", + " dense (Dense) (None, 1) 201 \n", + " \n", + "=================================================================\n", + "Total params: 40,601\n", + "Trainable params: 40,601\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "Epoch 1/150\n", + "1/1 [==============================] - 4s 4s/step - loss: 0.1358 - val_loss: 0.1403\n", + "Epoch 2/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 0.0512 - val_loss: 0.0151\n", + "Epoch 3/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 0.0079 - val_loss: 0.0109\n", + "Epoch 4/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 0.0020 - val_loss: 0.0761\n", + "Epoch 5/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0186 - val_loss: 0.1332\n", + "Epoch 6/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0344 - val_loss: 0.1432\n", + "Epoch 7/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0369 - val_loss: 0.1146\n", + "Epoch 8/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 0.0286 - val_loss: 0.0705\n", + "Epoch 9/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0165 - val_loss: 0.0309\n", + "Epoch 10/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0064 - val_loss: 0.0067\n", + "Epoch 11/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0012 - val_loss: 2.4796e-05\n", + "Epoch 12/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0012 - val_loss: 0.0060\n", + "Epoch 13/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0046 - val_loss: 0.0167\n", + "Epoch 14/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0089 - val_loss: 0.0250\n", + "Epoch 15/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0119 - val_loss: 0.0273\n", + "Epoch 16/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0126 - val_loss: 0.0232\n", + "Epoch 17/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 0.0109 - val_loss: 0.0153\n", + "Epoch 18/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0079 - val_loss: 0.0069\n", + "Epoch 19/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 0.0044 - val_loss: 0.0013\n", + "Epoch 20/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 0.0018 - val_loss: 1.7361e-04\n", + "Epoch 21/150\n", + "1/1 [==============================] - 0s 34ms/step - loss: 4.6921e-04 - val_loss: 0.0035\n", + "Epoch 22/150\n", + "1/1 [==============================] - 0s 35ms/step - loss: 6.1296e-04 - val_loss: 0.0097\n", + "Epoch 23/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 0.0018 - val_loss: 0.0160\n", + "Epoch 24/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 0.0032 - val_loss: 0.0201\n", + "Epoch 25/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 0.0043 - val_loss: 0.0206\n", + "Epoch 26/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 0.0044 - val_loss: 0.0176\n", + "Epoch 27/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 0.0038 - val_loss: 0.0125\n", + "Epoch 28/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 0.0026 - val_loss: 0.0070\n", + "Epoch 29/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 0.0013 - val_loss: 0.0027\n", + "Epoch 30/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 4.4365e-04 - val_loss: 3.8111e-04\n", + "Epoch 31/150\n", + "1/1 [==============================] - 0s 32ms/step - loss: 1.3242e-04 - val_loss: 9.4957e-05\n", + "Epoch 32/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 3.4446e-04 - val_loss: 0.0011\n", + "Epoch 33/150\n", + "1/1 [==============================] - 0s 33ms/step - loss: 8.5255e-04 - val_loss: 0.0025\n", + "Epoch 34/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 0.0014 - val_loss: 0.0034\n", + "Epoch 35/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 0.0016 - val_loss: 0.0034\n", + "Epoch 36/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0016 - val_loss: 0.0026\n", + "Epoch 37/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 0.0012 - val_loss: 0.0014\n", + "Epoch 38/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 7.4979e-04 - val_loss: 4.0524e-04\n", + "Epoch 39/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 3.0988e-04 - val_loss: 1.0932e-06\n", + "Epoch 40/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 5.9443e-05 - val_loss: 3.0524e-04\n", + "Epoch 41/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 4.6006e-05 - val_loss: 0.0011\n", + "Epoch 42/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 2.1511e-04 - val_loss: 0.0020\n", + "Epoch 43/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 4.4589e-04 - val_loss: 0.0026\n", + "Epoch 44/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 6.1132e-04 - val_loss: 0.0026\n", + "Epoch 45/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 6.3438e-04 - val_loss: 0.0021\n", + "Epoch 46/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 5.1457e-04 - val_loss: 0.0013\n", + "Epoch 47/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 3.1613e-04 - val_loss: 5.5759e-04\n", + "Epoch 48/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 1.2872e-04 - val_loss: 9.6631e-05\n", + "Epoch 49/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 2.2951e-05 - val_loss: 1.1998e-05\n", + "Epoch 50/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 2.1911e-05 - val_loss: 2.1755e-04\n", + "Epoch 51/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 9.8825e-05 - val_loss: 5.2317e-04\n", + "Epoch 52/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.9744e-04 - val_loss: 7.3731e-04\n", + "Epoch 53/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 2.6219e-04 - val_loss: 7.5233e-04\n", + "Epoch 54/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 2.6303e-04 - val_loss: 5.7753e-04\n", + "Epoch 55/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 2.0478e-04 - val_loss: 3.1400e-04\n", + "Epoch 56/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 1.1931e-04 - val_loss: 9.1250e-05\n", + "Epoch 57/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 4.6464e-05 - val_loss: 5.5289e-07\n", + "Epoch 58/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.4166e-05 - val_loss: 5.6228e-05\n", + "Epoch 59/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 2.6900e-05 - val_loss: 1.9963e-04\n", + "Epoch 60/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 6.7020e-05 - val_loss: 3.3837e-04\n", + "Epoch 61/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 1.0667e-04 - val_loss: 3.9688e-04\n", + "Epoch 62/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 1.2309e-04 - val_loss: 3.5120e-04\n", + "Epoch 63/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 1.0917e-04 - val_loss: 2.3268e-04\n", + "Epoch 64/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 7.4492e-05 - val_loss: 1.0310e-04\n", + "Epoch 65/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 3.7710e-05 - val_loss: 1.8492e-05\n", + "Epoch 66/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.5549e-05 - val_loss: 1.9955e-06\n", + "Epoch 67/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 1.4572e-05 - val_loss: 3.8244e-05\n", + "Epoch 68/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 2.9549e-05 - val_loss: 8.8578e-05\n", + "Epoch 69/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 4.8135e-05 - val_loss: 1.1572e-04\n", + "Epoch 70/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 5.8425e-05 - val_loss: 1.0356e-04\n", + "Epoch 71/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 5.5028e-05 - val_loss: 6.2381e-05\n", + "Epoch 72/150\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1/1 [==============================] - 0s 28ms/step - loss: 4.0764e-05 - val_loss: 1.9152e-05\n", + "Epoch 73/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 2.3823e-05 - val_loss: 4.2704e-08\n", + "Epoch 74/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.2548e-05 - val_loss: 1.5742e-05\n", + "Epoch 75/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.0956e-05 - val_loss: 5.7038e-05\n", + "Epoch 76/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.7268e-05 - val_loss: 1.0175e-04\n", + "Epoch 77/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 2.5808e-05 - val_loss: 1.2780e-04\n", + "Epoch 78/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 3.0734e-05 - val_loss: 1.2449e-04\n", + "Epoch 79/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 2.9276e-05 - val_loss: 9.6184e-05\n", + "Epoch 80/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 2.2761e-05 - val_loss: 5.7550e-05\n", + "Epoch 81/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 1.5174e-05 - val_loss: 2.4306e-05\n", + "Epoch 82/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 1.0468e-05 - val_loss: 5.3055e-06\n", + "Epoch 83/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.0336e-05 - val_loss: 1.5623e-08\n", + "Epoch 84/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.3634e-05 - val_loss: 1.6709e-06\n", + "Epoch 85/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.7513e-05 - val_loss: 3.1836e-06\n", + "Epoch 86/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 1.9329e-05 - val_loss: 1.8082e-06\n", + "Epoch 87/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.8117e-05 - val_loss: 1.3788e-08\n", + "Epoch 88/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.4860e-05 - val_loss: 2.6885e-06\n", + "Epoch 89/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.1582e-05 - val_loss: 1.2991e-05\n", + "Epoch 90/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 9.9947e-06 - val_loss: 2.9656e-05\n", + "Epoch 91/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.0539e-05 - val_loss: 4.7325e-05\n", + "Epoch 92/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.2335e-05 - val_loss: 5.9438e-05\n", + "Epoch 93/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 1.3925e-05 - val_loss: 6.1708e-05\n", + "Epoch 94/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.4243e-05 - val_loss: 5.4090e-05\n", + "Epoch 95/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 1.3189e-05 - val_loss: 4.0300e-05\n", + "Epoch 96/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 1.1522e-05 - val_loss: 2.5492e-05\n", + "Epoch 97/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 1.0252e-05 - val_loss: 1.3687e-05\n", + "Epoch 98/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 9.9786e-06 - val_loss: 6.3993e-06\n", + "Epoch 99/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 1.0592e-05 - val_loss: 2.9519e-06\n", + "Epoch 100/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.1463e-05 - val_loss: 1.8671e-06\n", + "Epoch 101/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 1.1921e-05 - val_loss: 2.2165e-06\n", + "Epoch 102/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.1679e-05 - val_loss: 4.0655e-06\n", + "Epoch 103/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.0944e-05 - val_loss: 7.9283e-06\n", + "Epoch 104/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.0205e-05 - val_loss: 1.3821e-05\n", + "Epoch 105/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 9.8716e-06 - val_loss: 2.0695e-05\n", + "Epoch 106/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.0032e-05 - val_loss: 2.6674e-05\n", + "Epoch 107/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 1.0446e-05 - val_loss: 2.9913e-05\n", + "Epoch 108/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 1.0759e-05 - val_loss: 2.9500e-05\n", + "Epoch 109/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 1.0747e-05 - val_loss: 2.5844e-05\n", + "Epoch 110/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 1.0443e-05 - val_loss: 2.0358e-05\n", + "Epoch 111/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 1.0066e-05 - val_loss: 1.4707e-05\n", + "Epoch 112/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8486e-06 - val_loss: 1.0118e-05\n", + "Epoch 113/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8802e-06 - val_loss: 7.0882e-06\n", + "Epoch 114/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 1.0072e-05 - val_loss: 5.5600e-06\n", + "Epoch 115/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 1.0249e-05 - val_loss: 5.2934e-06\n", + "Epoch 116/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 1.0277e-05 - val_loss: 6.1254e-06\n", + "Epoch 117/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.0149e-05 - val_loss: 7.9791e-06\n", + "Epoch 118/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 9.9651e-06 - val_loss: 1.0667e-05\n", + "Epoch 119/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8466e-06 - val_loss: 1.3735e-05\n", + "Epoch 120/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8504e-06 - val_loss: 1.6485e-05\n", + "Epoch 121/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 9.9414e-06 - val_loss: 1.8216e-05\n", + "Epoch 122/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.0032e-05 - val_loss: 1.8516e-05\n", + "Epoch 123/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 1.0051e-05 - val_loss: 1.7417e-05\n", + "Epoch 124/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 9.9901e-06 - val_loss: 1.5359e-05\n", + "Epoch 125/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 9.8990e-06 - val_loss: 1.2963e-05\n", + "Epoch 126/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 9.8395e-06 - val_loss: 1.0794e-05\n", + "Epoch 127/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8410e-06 - val_loss: 9.2127e-06\n", + "Epoch 128/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8856e-06 - val_loss: 8.3720e-06\n", + "Epoch 129/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 9.9287e-06 - val_loss: 8.2850e-06\n", + "Epoch 130/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 9.9349e-06 - val_loss: 8.8960e-06\n", + "Epoch 131/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 9.9022e-06 - val_loss: 1.0086e-05\n", + "Epoch 132/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 9.8567e-06 - val_loss: 1.1645e-05\n", + "Epoch 133/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 9.8290e-06 - val_loss: 1.3271e-05\n", + "Epoch 134/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 9.8325e-06 - val_loss: 1.4617e-05\n", + "Epoch 135/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 9.8556e-06 - val_loss: 1.5394e-05\n", + "Epoch 136/150\n", + "1/1 [==============================] - 0s 28ms/step - loss: 9.8750e-06 - val_loss: 1.5461e-05\n", + "Epoch 137/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 9.8746e-06 - val_loss: 1.4877e-05\n", + "Epoch 138/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8558e-06 - val_loss: 1.3863e-05\n", + "Epoch 139/150\n", + "1/1 [==============================] - 0s 31ms/step - loss: 9.8336e-06 - val_loss: 1.2705e-05\n", + "Epoch 140/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8227e-06 - val_loss: 1.1674e-05\n", + "Epoch 141/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8274e-06 - val_loss: 1.0959e-05\n", + "Epoch 142/150\n", + "1/1 [==============================] - 0s 27ms/step - loss: 9.8396e-06 - val_loss: 1.0660e-05\n", + "Epoch 143/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8474e-06 - val_loss: 1.0788e-05\n", + "Epoch 144/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8444e-06 - val_loss: 1.1292e-05\n", + "Epoch 145/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8337e-06 - val_loss: 1.2054e-05\n", + "Epoch 146/150\n", + "1/1 [==============================] - 0s 30ms/step - loss: 9.8234e-06 - val_loss: 1.2912e-05\n", + "Epoch 147/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8202e-06 - val_loss: 1.3680e-05\n", + "Epoch 148/150\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1/1 [==============================] - 0s 28ms/step - loss: 9.8241e-06 - val_loss: 1.4195e-05\n", + "Epoch 149/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8303e-06 - val_loss: 1.4361e-05\n", + "Epoch 150/150\n", + "1/1 [==============================] - 0s 29ms/step - loss: 9.8323e-06 - val_loss: 1.4168e-05\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE: 0.0001688185180222488\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_11679/3370771014.py:33: DeprecationWarning: setting an array element with a sequence. This was supported in some cases where the elements are arrays with a single element. For example `np.array([1, np.array([2])], dtype=int)`. In the future this will raise the same ValueError as `np.array([1, [2]], dtype=int)`.\n", + " next_input = np.array([[last, next[0]]], dtype=np.float64)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 8.960891042000014\n" + ] + } + ], "source": [ "def test_rnn (x1, y_test, plot_min, plot_max):\n", " \"\"\"\n", @@ -1643,9 +2108,7 @@ { "cell_type": "markdown", "id": "4711b0d4", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Other Things to Try\n", "\n", @@ -1663,13 +2126,382 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 6, "id": "22123a0f", - "metadata": { - "collapsed": false, - "editable": true - }, - "outputs": [], + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model_1\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " input_2 (InputLayer) [(None, 2, 1)] 0 \n", + " \n", + " RNN1 (SimpleRNN) (None, 2, 500) 251000 \n", + " \n", + " RNN2 (SimpleRNN) (None, 500) 500500 \n", + " \n", + " dense (Dense) (None, 1) 501 \n", + " \n", + "=================================================================\n", + "Total params: 752,001\n", + "Trainable params: 752,001\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "Epoch 1/150\n", + "1/1 [==============================] - 3s 3s/step - loss: 2.3905 - val_loss: 2.6248\n", + "Epoch 2/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 4.2149 - val_loss: 1.0031\n", + "Epoch 3/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 2.0713 - val_loss: 0.1563\n", + "Epoch 4/150\n", + "1/1 [==============================] - 0s 50ms/step - loss: 0.0429 - val_loss: 2.2720\n", + "Epoch 5/150\n", + "1/1 [==============================] - 0s 46ms/step - loss: 1.2154 - val_loss: 3.1357\n", + "Epoch 6/150\n", + "1/1 [==============================] - 0s 50ms/step - loss: 1.8554 - val_loss: 1.8682\n", + "Epoch 7/150\n", + "1/1 [==============================] - 0s 47ms/step - loss: 0.9310 - val_loss: 0.4494\n", + "Epoch 8/150\n", + "1/1 [==============================] - 0s 50ms/step - loss: 0.1030 - val_loss: 4.2951e-08\n", + "Epoch 9/150\n", + "1/1 [==============================] - 0s 60ms/step - loss: 0.2212 - val_loss: 0.1764\n", + "Epoch 10/150\n", + "1/1 [==============================] - 0s 48ms/step - loss: 0.7531 - val_loss: 0.2583\n", + "Epoch 11/150\n", + "1/1 [==============================] - 0s 52ms/step - loss: 0.9096 - val_loss: 0.0959\n", + "Epoch 12/150\n", + "1/1 [==============================] - 0s 51ms/step - loss: 0.5790 - val_loss: 0.0046\n", + "Epoch 13/150\n", + "1/1 [==============================] - 0s 50ms/step - loss: 0.1685 - val_loss: 0.2457\n", + "Epoch 14/150\n", + "1/1 [==============================] - 0s 46ms/step - loss: 0.0473 - val_loss: 0.7292\n", + "Epoch 15/150\n", + "1/1 [==============================] - 0s 49ms/step - loss: 0.2274 - val_loss: 1.1137\n", + "Epoch 16/150\n", + "1/1 [==============================] - 0s 49ms/step - loss: 0.4414 - val_loss: 1.1417\n", + "Epoch 17/150\n", + "1/1 [==============================] - 0s 49ms/step - loss: 0.4583 - val_loss: 0.8415\n", + "Epoch 18/150\n", + "1/1 [==============================] - 0s 47ms/step - loss: 0.2861 - val_loss: 0.4378\n", + "Epoch 19/150\n", + "1/1 [==============================] - 0s 49ms/step - loss: 0.0989 - val_loss: 0.1418\n", + "Epoch 20/150\n", + "1/1 [==============================] - 0s 50ms/step - loss: 0.0441 - val_loss: 0.0178\n", + "Epoch 21/150\n", + "1/1 [==============================] - 0s 47ms/step - loss: 0.1257 - val_loss: 2.0294e-04\n", + "Epoch 22/150\n", + "1/1 [==============================] - 0s 45ms/step - loss: 0.2330 - val_loss: 0.0019\n", + "Epoch 23/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 0.2590 - val_loss: 0.0016\n", + "Epoch 24/150\n", + "1/1 [==============================] - 0s 42ms/step - loss: 0.1885 - val_loss: 0.0415\n", + "Epoch 25/150\n", + "1/1 [==============================] - 0s 45ms/step - loss: 0.0899 - val_loss: 0.1619\n", + "Epoch 26/150\n", + "1/1 [==============================] - 0s 48ms/step - loss: 0.0423 - val_loss: 0.3437\n", + "Epoch 27/150\n", + "1/1 [==============================] - 0s 44ms/step - loss: 0.0687 - val_loss: 0.5095\n", + "Epoch 28/150\n", + "1/1 [==============================] - 0s 43ms/step - loss: 0.1266 - val_loss: 0.5778\n", + "Epoch 29/150\n", + "1/1 [==============================] - 0s 46ms/step - loss: 0.1558 - val_loss: 0.5216\n", + "Epoch 30/150\n", + "1/1 [==============================] - 0s 49ms/step - loss: 0.1317 - val_loss: 0.3810\n", + "Epoch 31/150\n", + "1/1 [==============================] - 0s 49ms/step - loss: 0.0798 - val_loss: 0.2271\n", + "Epoch 32/150\n", + "1/1 [==============================] - 0s 42ms/step - loss: 0.0448 - val_loss: 0.1133\n", + "Epoch 33/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0492 - val_loss: 0.0531\n", + "Epoch 34/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0787 - val_loss: 0.0326\n", + "Epoch 35/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.1003 - val_loss: 0.0373\n", + "Epoch 36/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0943 - val_loss: 0.0676\n", + "Epoch 37/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0681 - val_loss: 0.1296\n", + "Epoch 38/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0457 - val_loss: 0.2170\n", + "Epoch 39/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0437 - val_loss: 0.3036\n", + "Epoch 40/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0584 - val_loss: 0.3554\n", + "Epoch 41/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0721 - val_loss: 0.3522\n", + "Epoch 42/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0712 - val_loss: 0.2999\n", + "Epoch 43/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0576 - val_loss: 0.2249\n", + "Epoch 44/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0445 - val_loss: 0.1554\n", + "Epoch 45/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0425 - val_loss: 0.1082\n", + "Epoch 46/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0504 - val_loss: 0.0862\n", + "Epoch 47/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0581 - val_loss: 0.0871\n", + "Epoch 48/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0577 - val_loss: 0.1088\n", + "Epoch 49/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0501 - val_loss: 0.1487\n", + "Epoch 50/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0430 - val_loss: 0.1988\n", + "Epoch 51/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0423 - val_loss: 0.2440\n", + "Epoch 52/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0469 - val_loss: 0.2681\n", + "Epoch 53/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0510 - val_loss: 0.2632\n", + "Epoch 54/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0501 - val_loss: 0.2336\n", + "Epoch 55/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0455 - val_loss: 0.1928\n", + "Epoch 56/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0420 - val_loss: 0.1552\n", + "Epoch 57/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0424 - val_loss: 0.1301\n", + "Epoch 58/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0453 - val_loss: 0.1209\n", + "Epoch 59/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0470 - val_loss: 0.1275\n", + "Epoch 60/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0457 - val_loss: 0.1474\n", + "Epoch 61/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0429 - val_loss: 0.1756\n", + "Epoch 62/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0416 - val_loss: 0.2038\n", + "Epoch 63/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0425 - val_loss: 0.2226\n", + "Epoch 64/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0441 - val_loss: 0.2256\n", + "Epoch 65/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0445 - val_loss: 0.2130\n", + "Epoch 66/150\n", + "1/1 [==============================] - 0s 42ms/step - loss: 0.0432 - val_loss: 0.1909\n", + "Epoch 67/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0418 - val_loss: 0.1679\n", + "Epoch 68/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0416 - val_loss: 0.1508\n", + "Epoch 69/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0425 - val_loss: 0.1435\n", + "Epoch 70/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0432 - val_loss: 0.1468\n", + "Epoch 71/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0428 - val_loss: 0.1589\n", + "Epoch 72/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0419 - val_loss: 0.1760\n", + "Epoch 73/150\n", + "1/1 [==============================] - 0s 42ms/step - loss: 0.0414 - val_loss: 0.1924\n", + "Epoch 74/150\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1/1 [==============================] - 0s 38ms/step - loss: 0.0418 - val_loss: 0.2025\n", + "Epoch 75/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0423 - val_loss: 0.2031\n", + "Epoch 76/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0423 - val_loss: 0.1947\n", + "Epoch 77/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0418 - val_loss: 0.1813\n", + "Epoch 78/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0414 - val_loss: 0.1679\n", + "Epoch 79/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0414 - val_loss: 0.1588\n", + "Epoch 80/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0418 - val_loss: 0.1563\n", + "Epoch 81/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0419 - val_loss: 0.1605\n", + "Epoch 82/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0417 - val_loss: 0.1695\n", + "Epoch 83/150\n", + "1/1 [==============================] - 0s 42ms/step - loss: 0.0413 - val_loss: 0.1801\n", + "Epoch 84/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0413 - val_loss: 0.1884\n", + "Epoch 85/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0415 - val_loss: 0.1917\n", + "Epoch 86/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0416 - val_loss: 0.1890\n", + "Epoch 87/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0415 - val_loss: 0.1819\n", + "Epoch 88/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0413 - val_loss: 0.1735\n", + "Epoch 89/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0412 - val_loss: 0.1667\n", + "Epoch 90/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0413 - val_loss: 0.1637\n", + "Epoch 91/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0414 - val_loss: 0.1651\n", + "Epoch 92/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0413 - val_loss: 0.1700\n", + "Epoch 93/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0412 - val_loss: 0.1764\n", + "Epoch 94/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0411 - val_loss: 0.1819\n", + "Epoch 95/150\n", + "1/1 [==============================] - 0s 42ms/step - loss: 0.0412 - val_loss: 0.1844\n", + "Epoch 96/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0412 - val_loss: 0.1833\n", + "Epoch 97/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0412 - val_loss: 0.1792\n", + "Epoch 98/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0411 - val_loss: 0.1739\n", + "Epoch 99/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0410 - val_loss: 0.1696\n", + "Epoch 100/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0411 - val_loss: 0.1677\n", + "Epoch 101/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0411 - val_loss: 0.1685\n", + "Epoch 102/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0411 - val_loss: 0.1716\n", + "Epoch 103/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0410 - val_loss: 0.1756\n", + "Epoch 104/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0410 - val_loss: 0.1788\n", + "Epoch 105/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0410 - val_loss: 0.1800\n", + "Epoch 106/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0410 - val_loss: 0.1790\n", + "Epoch 107/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0409 - val_loss: 0.1762\n", + "Epoch 108/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0409 - val_loss: 0.1729\n", + "Epoch 109/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0409 - val_loss: 0.1705\n", + "Epoch 110/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0409 - val_loss: 0.1697\n", + "Epoch 111/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0409 - val_loss: 0.1707\n", + "Epoch 112/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0408 - val_loss: 0.1729\n", + "Epoch 113/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0408 - val_loss: 0.1752\n", + "Epoch 114/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0408 - val_loss: 0.1768\n", + "Epoch 115/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0408 - val_loss: 0.1770\n", + "Epoch 116/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0408 - val_loss: 0.1758\n", + "Epoch 117/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0408 - val_loss: 0.1738\n", + "Epoch 118/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0407 - val_loss: 0.1719\n", + "Epoch 119/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0407 - val_loss: 0.1708\n", + "Epoch 120/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0407 - val_loss: 0.1708\n", + "Epoch 121/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0407 - val_loss: 0.1719\n", + "Epoch 122/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0407 - val_loss: 0.1734\n", + "Epoch 123/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0406 - val_loss: 0.1746\n", + "Epoch 124/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0406 - val_loss: 0.1751\n", + "Epoch 125/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0406 - val_loss: 0.1746\n", + "Epoch 126/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0406 - val_loss: 0.1734\n", + "Epoch 127/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0406 - val_loss: 0.1721\n", + "Epoch 128/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0405 - val_loss: 0.1712\n", + "Epoch 129/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0405 - val_loss: 0.1709\n", + "Epoch 130/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0405 - val_loss: 0.1714\n", + "Epoch 131/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0405 - val_loss: 0.1723\n", + "Epoch 132/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0405 - val_loss: 0.1731\n", + "Epoch 133/150\n", + "1/1 [==============================] - 0s 41ms/step - loss: 0.0404 - val_loss: 0.1735\n", + "Epoch 134/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0404 - val_loss: 0.1733\n", + "Epoch 135/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0404 - val_loss: 0.1725\n", + "Epoch 136/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0404 - val_loss: 0.1717\n", + "Epoch 137/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0404 - val_loss: 0.1710\n", + "Epoch 138/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0403 - val_loss: 0.1708\n", + "Epoch 139/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0403 - val_loss: 0.1710\n", + "Epoch 140/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0403 - val_loss: 0.1715\n", + "Epoch 141/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0403 - val_loss: 0.1720\n", + "Epoch 142/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0403 - val_loss: 0.1722\n", + "Epoch 143/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0402 - val_loss: 0.1720\n", + "Epoch 144/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0402 - val_loss: 0.1715\n", + "Epoch 145/150\n", + "1/1 [==============================] - 0s 40ms/step - loss: 0.0402 - val_loss: 0.1709\n", + "Epoch 146/150\n", + "1/1 [==============================] - 0s 37ms/step - loss: 0.0402 - val_loss: 0.1705\n", + "Epoch 147/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0402 - val_loss: 0.1703\n", + "Epoch 148/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0401 - val_loss: 0.1705\n", + "Epoch 149/150\n", + "1/1 [==============================] - 0s 38ms/step - loss: 0.0401 - val_loss: 0.1708\n", + "Epoch 150/150\n", + "1/1 [==============================] - 0s 39ms/step - loss: 0.0401 - val_loss: 0.1710\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE: 0.33032583548035827\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/td/3yk470mj5p931p9dtkk0y6jw0000gn/T/ipykernel_11679/3370771014.py:33: DeprecationWarning: setting an array element with a sequence. This was supported in some cases where the elements are arrays with a single element. For example `np.array([1, np.array([2])], dtype=int)`. In the future this will raise the same ValueError as `np.array([1, [2]], dtype=int)`.\n", + " next_input = np.array([[last, next[0]]], dtype=np.float64)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time: 10.101145834000022\n" + ] + } + ], "source": [ "def rnn_2layers(length_of_sequences, batch_size = None, stateful = False):\n", " \"\"\"\n", @@ -1762,9 +2594,7 @@ { "cell_type": "markdown", "id": "50cd4d20", - "metadata": { - "editable": true - }, + "metadata": {}, "source": [ "## Other Types of Recurrent Neural Networks\n", "\n", @@ -1788,10 +2618,7 @@ "cell_type": "code", "execution_count": 14, "id": "5c3d5a53", - "metadata": { - "collapsed": false, - "editable": true - }, + "metadata": {}, "outputs": [], "source": [ "def lstm_2layers(length_of_sequences, batch_size = None, stateful = False):\n", @@ -1987,7 +2814,25 @@ ] } ], - "metadata": {}, + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, "nbformat": 4, "nbformat_minor": 5 }