diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..e5b8a1e --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,46 @@ +name: stella-ci + +on: + push: + branches: [ main, feat/**, fix/** ] + pull_request: + +jobs: + test: + strategy: + fail-fast: false + matrix: + include: + - os: ubuntu-latest + backend: jax + python: '3.12' + - os: ubuntu-latest + backend: torch + python: '3.12' + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@v4 + # macOS-specific gettext step removed; both matrix jobs run on Linux now + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python }} + - name: Install dependencies (base) + run: | + python -m pip install --upgrade pip + pip install -r requirements.txt + - name: Install backend (JAX) + if: matrix.backend == 'jax' + run: | + pip install -r requirements-jax.txt + echo "KERAS_BACKEND=jax" >> $GITHUB_ENV + - name: Install backend (Torch) + if: matrix.backend == 'torch' + run: | + pip install -r requirements-torch.txt + echo "KERAS_BACKEND=torch" >> $GITHUB_ENV + - name: Install package + run: | + python -m pip install --upgrade pip build setuptools wheel + pip install . + - name: Run tests + run: pytest stella/tests -q diff --git a/.github/workflows/docs-page.yml b/.github/workflows/docs-page.yml deleted file mode 100644 index 8e722d2..0000000 --- a/.github/workflows/docs-page.yml +++ /dev/null @@ -1,20 +0,0 @@ -name : Build and Deply -on : [push] - -jobs : - build-and-deploy: - runs-on: ubuntu-latest - steps: - - name : Checkout - uses : actions/checkout@v2.3.1 - - - name : Install and Build - run : | - npm install - npm run build - - - name : Deploy - uses : JamesIves/github-pages-deploy-action@4.0.0 - with : - branch : master - folder : build \ No newline at end of file diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 0000000..184b884 --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,61 @@ +name: Deploy Docs + +on: + push: + branches: + - main + - feat/** + - fix/** + pull_request: + branches: + - main + - feat/** + - fix/** + workflow_dispatch: + +permissions: + contents: read + pages: write + id-token: write + +concurrency: + group: 'pages' + cancel-in-progress: true + +jobs: + build: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.12' + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install -e .[dev] + python -m pip install mkdocs mkdocs-material mkdocstrings[python] mkdocs-jupyter mkdocs-exclude + + - name: Build MkDocs site + run: | + mkdocs build --strict + + - name: Upload artifact + uses: actions/upload-pages-artifact@v3 + with: + path: site + + deploy: + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + runs-on: ubuntu-latest + needs: build + steps: + - name: Deploy to GitHub Pages + id: deployment + uses: actions/deploy-pages@v4 diff --git a/.github/workflows/greetings.yml b/.github/workflows/greetings.yml deleted file mode 100644 index 6efebd9..0000000 --- a/.github/workflows/greetings.yml +++ /dev/null @@ -1,12 +0,0 @@ -name: Greetings - -on: [pull_request, issues] - -jobs: - greeting: - runs-on: ubuntu-latest - steps: - - uses: actions/first-interaction@v1 - with: - repo-token: ${{ secrets.GITHUB_TOKEN }} - issue-message: 'Hi there! This is a test of github actions.' diff --git a/.github/workflows/stella-tests.yml b/.github/workflows/stella-tests.yml index f3cb962..2146c11 100644 --- a/.github/workflows/stella-tests.yml +++ b/.github/workflows/stella-tests.yml @@ -8,19 +8,16 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - name: [3.6, 3.7] + name: [3.12] include: - - name: 3.6 - python-version: 3.6 - pytest-command: poetry run pytest - - name: 3.7 - python-version: 3.7 + - name: 3.12 + python-version: 3.12 pytest-command: poetry run pytest steps: - - uses: actions/checkout@v1 + - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v1 + uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install dependencies @@ -28,6 +25,10 @@ jobs: python -m pip install --upgrade pip pip install flake8 pytest if [ -f requirements.txt ]; then pip install -r requirements.txt; fi + - name: Install package and dev deps (with JAX) + run: | + python -m pip install --upgrade setuptools wheel + python -m pip install -e ".[dev,jax]" - name: Test with pytest run: | pytest --doctest-modules --cov=com --cov-report=xml --cov-report=html \ No newline at end of file diff --git a/.gitignore b/.gitignore index 19902c1..4949cff 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,6 @@ +mastDownload/ +stella/mastDownload/ +*.fits __pycache__ */__pycache__ */*/__pycache__ @@ -16,3 +19,8 @@ dist *.cppimporthash .rendered.* *.egg-info + +## Local examples and helpers (not part of package) +notebooks/jax_keras.ipynb +scripts/ +site/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..2a22c54 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,9 @@ +repos: + - repo: https://github.com/psf/black + rev: 24.10.0 + hooks: + - id: black + name: black (python formatter) + language_version: python3 + types: [python] + additional_dependencies: [] diff --git a/.travis.yml b/.travis.yml index 626a84c..02dbeca 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,11 +1,15 @@ -dist: xenial +dist: focal language: python -python: 3.7 matrix: include: - os: linux + python: 3.10 + env: BACKEND=jax + - os: osx + language: shell + env: BACKEND=torch PYTHON=3.10 addons: apt_packages: @@ -14,26 +18,15 @@ addons: cache: pip before_install: - - sudo apt-get install python3-pip - - sudo pip3 install requests + - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sudo apt-get install -y python3-pip; fi + - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sudo pip3 install requests; fi install: - - pip install tornado - - pip install tensorflow>2.1.0 - - pip install scipy!=1.4.1 - - pip install lightkurve - - pip install astropy - - pip install astroquery - - pip install tqdm - - pip install sphinx - - pip install nbsphinx - - pip install cython - - pip install codecov - - pip install coverage - - pip install pytest - - pip install pytest-cov - - pip install lxml - - pip install pybind11 + - if [ "$TRAVIS_OS_NAME" = "osx" ]; then python3 -m pip install --upgrade pip; else pip install --upgrade pip; fi + - if [ "$TRAVIS_OS_NAME" = "osx" ]; then python3 -m pip install -r requirements.txt; else pip install -r requirements.txt; fi + - if [ "$BACKEND" = "jax" ]; then pip install -r requirements-jax.txt; export KERAS_BACKEND=jax; fi + - if [ "$BACKEND" = "torch" ]; then python3 -m pip install -r requirements-torch.txt; export KERAS_BACKEND=torch; fi + - pip install sphinx nbsphinx - python setup.py install script: diff --git a/README.md b/README.md index fd12aa4..0b9524b 100644 --- a/README.md +++ b/README.md @@ -8,6 +8,9 @@ PyPI - Downloads + + Docs Deploy + GitHub Pages

@@ -29,6 +32,52 @@ Alternatively you can install the current development version of stella: cd stella python setup.py install +Backends and models +------------------- +- stella uses Keras Core and works with multiple backends: JAX or PyTorch. Choose one, install, and set it before importing `keras`: + +```bash +# JAX +pip install -r requirements-jax.txt +export KERAS_BACKEND=jax + +# or PyTorch +pip install -r requirements-torch.txt +export KERAS_BACKEND=torch +``` + + Models are saved/loaded in the native Keras format (`.keras`). If you have older `.h5` + or legacy SavedModel models, use the included converter: + +```bash +# Convert .h5 or legacy SavedModel to .keras (TensorFlow backend only for conversion) +python scripts/convert_h5_to_keras.py /path/to/models -r --cadences 350 -o /path/to/out +``` + +Pipeline quickstart +------------------- +- See the new pipeline guide for a friendly, end-to-end example (TIC 62124646): + https://afeinstein20.github.io/stella/getting_started/pipeline.html + +Swap backends quickly +--------------------- +- Inspect availability and devices: + +```python +import stella +stella.check_backend() +``` + +- Prepare a swap (restart your interpreter after): + +```python +import stella +stella.swap_backend('torch', accelerator='mps') # Apple Silicon +# or +stella.swap_backend('jax', accelerator='cpu') +``` +``` +

If your work uses the stella software, please cite Feinstein, Montet, & Ansdell (2020).

diff --git a/docs/api.md b/docs/api.md new file mode 100644 index 0000000..7fae8d4 --- /dev/null +++ b/docs/api.md @@ -0,0 +1,3 @@ +# API Reference + +::: stella diff --git a/docs/assets/stella_logo.png b/docs/assets/stella_logo.png new file mode 100644 index 0000000..091dc07 Binary files /dev/null and b/docs/assets/stella_logo.png differ diff --git a/docs/conf.py b/docs/conf.py index 2f95abe..ed3e2c3 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -174,3 +174,7 @@ if not on_rtd: # only import and set the theme if we're building docs locally html_theme = 'sphinx_rtd_theme' html_theme_path = ['.',] + +# Ensure theme templates have a default 'style' context to avoid Jinja errors +html_context = globals().get('html_context', {}) +html_context.setdefault('style', 'default') diff --git a/docs/getting_started/about.md b/docs/getting_started/about.md new file mode 100644 index 0000000..a8b7a7e --- /dev/null +++ b/docs/getting_started/about.md @@ -0,0 +1,11 @@ +# About stella + +stella identifies flares in TESS short‑cadence data with a convolutional neural network (CNN). + +In its simplest form, stella takes a pre‑trained CNN (details in Feinstein et al.) and a light curve `(time, flux, flux_err)` and returns a probability light curve. Values are between 0 and 1, where 1 indicates a likely flare. + +You can also train your own customized CNN architecture. See the Quickstart tutorial for a walkthrough. + +Links: +- Paper: Feinstein, Montet, & Ansdell (2020, JOSS) +- Issues: https://github.com/benjaminpope/stella/issues diff --git a/docs/getting_started/backends.md b/docs/getting_started/backends.md new file mode 100644 index 0000000..e99f6bf --- /dev/null +++ b/docs/getting_started/backends.md @@ -0,0 +1,49 @@ +# Backends (JAX and PyTorch) + +stella uses Keras 3, which can run on multiple numerical backends. You can use either the JAX or the PyTorch backend with the same stella code. + +Quick facts +----------- +- Select backend via the environment variable `KERAS_BACKEND` before importing `keras`. +- The stella code is backend‑agnostic; no changes are required besides selecting the backend and installing the backend packages. + +Setup: JAX +----------- + +```bash +pip install -U keras jax jaxlib +export KERAS_BACKEND=jax +``` + +Setup: PyTorch +-------------- + +```bash +pip install -U keras torch +export KERAS_BACKEND=torch +``` + +Usage is identical +------------------ + +```python +import os +os.environ.setdefault("KERAS_BACKEND", "jax") # or "torch" +import keras +m = keras.models.load_model("/path/to/model.keras", compile=False) +y = m.predict(x) +``` + +Troubleshooting +--------------- +- If you see a backend mismatch, ensure `KERAS_BACKEND` is set before any import of `keras` occurs in your Python process. +- Some ops or layers may have different performance characteristics across backends. + +Inspect, swap, and benchmark +---------------------------- + +```python +import stella +stella.check_backend() +stella.swap_backend('torch', accelerator='mps') # prepare env for PyTorch Metal +``` diff --git a/docs/getting_started/backends.rst b/docs/getting_started/backends.rst new file mode 100644 index 0000000..3a27428 --- /dev/null +++ b/docs/getting_started/backends.rst @@ -0,0 +1,76 @@ +.. _backends: + +Backends (JAX and PyTorch) +========================== + +stella uses Keras Core, which can run on multiple numerical backends. You can use either the JAX or the PyTorch backend with the same stella code. + +Quick facts +----------- +- Select backend via the environment variable ``KERAS_BACKEND`` before importing ``keras``. +- Keras JIT-compiles model functions under the hood (via XLA for JAX, TorchScript-like tracing for PyTorch where applicable). You do not need to wrap calls in ``jax.jit`` or Torch decorators. +- The stella code is backend-agnostic; no changes are required besides selecting the backend and installing the backend packages. + +Setup: JAX +---------- + +.. code-block:: bash + + pip install -U keras jax jaxlib + export KERAS_BACKEND=jax + +Notes (Apple Silicon): JAX runs on CPU out of the box. If you need GPU/Metal acceleration, consult the JAX docs for the current macOS acceleration story. + +Setup: PyTorch +-------------- + +.. code-block:: bash + + pip install -U keras torch + export KERAS_BACKEND=torch + +Notes (Apple Silicon): PyTorch supports the ``mps`` device via Metal on Apple Silicon; Keras-Core over Torch can leverage this where supported by the operators used in your model. + +Usage is identical + +Once the backend is selected, load models and run predictions the same way: + +.. code-block:: python + + import os + os.environ.setdefault("KERAS_BACKEND", "jax") # or "torch" + import keras + m = keras.models.load_model("/path/to/model.keras", compile=False) + y = m.predict(x) + +Troubleshooting +--------------- +- If you see a backend mismatch, ensure ``KERAS_BACKEND`` is set before any import of ``keras`` occurs in your Python process. +- Some ops or layers may have different performance characteristics across backends. If you encounter unsupported ops on a given backend, please open an issue. + +Inspect, swap, and benchmark +---------------------------- +- Inspect what's available and the current selection: + +.. code-block:: python + + import stella + stella.check_backend() + +- Prepare to swap backends and accelerators (restart your Python session after calling): + +.. code-block:: python + + import stella + # Switch to PyTorch with Apple Metal (MPS) + stella.swap_backend('torch', accelerator='mps') + # Or switch to JAX on CPU + stella.swap_backend('jax', accelerator='cpu') + +- Benchmark prediction speed on TIC 62124646 using your model across available backends: + +.. code-block:: python + + import stella + res = stella.benchmark(model_path="/path/to/model.keras") + print(res) diff --git a/docs/getting_started/installation.md b/docs/getting_started/installation.md new file mode 100644 index 0000000..9a5187c --- /dev/null +++ b/docs/getting_started/installation.md @@ -0,0 +1,64 @@ +# Installation + +Choose a backend and install dependencies: + +```bash +# JAX (CPU) +Install stella and choose a backend. + +Via pip extras +-------------- + +```bash +# JAX (CPU) +pip install "stella[jax]" + +# JAX on macOS with Metal (Apple Silicon) +pip install "stella[jax-mps]" + +# PyTorch +pip install "stella[torch]" +``` + +From source (development) +------------------------- + +```bash +git clone https://github.com/benjaminpope/stella +cd stella +pip install -e .[dev] +``` + +Selecting a backend +------------------- + +Set the backend before importing `keras`: + +```bash +export KERAS_BACKEND=jax # or torch +``` + +Quick sanity check +------------------ + +```python +import os +os.environ.setdefault("KERAS_BACKEND", "jax") # or "torch" +import keras +print("Backend:", keras.backend.backend()) +m = keras.Sequential([ + keras.layers.Input((8,)), + keras.layers.Dense(4, activation='relu'), + keras.layers.Dense(1, activation='sigmoid'), +]) +print(m([[0]*8]).shape) +``` + +Backend validation at runtime +----------------------------- + +```python +import stella +stella.require_backend() # raises with install hint if backend missing +``` +``` diff --git a/docs/getting_started/installation.rst b/docs/getting_started/installation.rst index 1b60427..57f9362 100644 --- a/docs/getting_started/installation.rst +++ b/docs/getting_started/installation.rst @@ -3,13 +3,88 @@ Installation ============ -To install stella with pip:: +To install stella with pip, pick a backend extras group: + +.. code-block:: bash + + # JAX (CPU) + pip install stella[jax] + + # JAX on macOS with Metal (Apple Silicon) + pip install stella[jax-mps] + + # PyTorch + pip install stella[torch] - pip install stella - Alternatively you can install the current development version of stella:: - git clone https://github.com/afeinstein20/stella + git clone https://github.com/afeinstein20/stella cd stella python setup.py install + +Backends +-------- +stella uses Keras Core and works with multiple backends: JAX or PyTorch. You can choose either. + +- Select the backend before importing ``keras``: + + .. code-block:: bash + + export KERAS_BACKEND=jax # or torch + +Switching backends (JAX ↔ PyTorch) +---------------------------------- + +- Install with the matching extras and set the env var before importing ``keras``: + + .. code-block:: bash + + # JAX + pip install stella[jax] + export KERAS_BACKEND=jax + + # PyTorch + pip install stella[torch] + export KERAS_BACKEND=torch + +- Quick sanity check in Python: + + .. code-block:: python + + import os + os.environ.setdefault("KERAS_BACKEND", "jax") # or "torch" + import keras + print("Backend:", keras.backend.backend()) + m = keras.Sequential([ + keras.layers.Input((8,)), + keras.layers.Dense(4, activation='relu'), + keras.layers.Dense(1, activation='sigmoid'), + ]) + print(m.predict([[0]*8]).shape) + +Backend validation +------------------ +To ensure a backend is available at runtime, call: + +.. code-block:: python + + import stella + stella.require_backend() # raises with install hint if backend missing + +Next steps +---------- +- For an end-to-end example using the high-level helpers, see :doc:`pipeline`. + +Tip: Swapping at runtime +------------------------ +Because the backend is chosen when ``keras`` is first imported, changing backends inside a running Python session is not supported. stella provides helpers to inspect and prepare for a swap: + +.. code-block:: python + + import stella + stella.check_backend() # shows installed backends and devices + # Prepare env for torch with Apple Metal (MPS); restart recommended + stella.swap_backend('torch', accelerator='mps') + +Then restart your Python session and re-import your code. diff --git a/docs/getting_started/other_features.ipynb b/docs/getting_started/other_features.ipynb index fc242fe..c3d1a03 100644 --- a/docs/getting_started/other_features.ipynb +++ b/docs/getting_started/other_features.ipynb @@ -16,15 +16,15 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import os, sys\n", - "sys.path.insert(1, '/Users/arcticfox/Documents/GitHub/stella/')\n", + "\n", "import stella\n", "import numpy as np\n", - "from tqdm import tqdm_notebook\n", + "from tqdm.auto import tqdm\n", "import matplotlib.pyplot as plt\n", "\n", "plt.rcParams['font.size'] = 20" @@ -39,20 +39,31 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "//anaconda3/lib/python3.7/site-packages/lightkurve/lightcurvefile.py:47: LightkurveWarning: `LightCurveFile.header` is deprecated, please use `LightCurveFile.get_header()` instead.\n", - " LightkurveWarning)\n" + "/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/lightkurve/config/__init__.py:119: UserWarning: The default Lightkurve cache directory, used by download(), etc., has been moved to /Users/benpope/.lightkurve/cache. Please move all the files in the legacy directory /Users/benpope/.lightkurve-cache to the new location and remove the legacy directory. Refer to https://docs.lightkurve.org/reference/config.html#default-cache-directory-migration for more information.\n", + " warnings.warn(\n", + "/var/folders/vx/lm_q_1ld7c13_fbqfscs9n4w0000gq/T/ipykernel_44312/692024527.py:2: LightkurveDeprecationWarning: The search_lightcurvefile function is deprecated and may be removed in a future version.\n", + " Use search_lightcurve() instead.\n", + " lc = search_lightcurvefile(target='tic62124646', mission='TESS')\n", + "/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/lightkurve/search.py:424: LightkurveWarning: Warning: 14 files available to download. Only the first file has been downloaded. Please use `download_all()` or specify additional criteria (e.g. quarter, campaign, or sector) to limit your search.\n", + " warnings.warn(\n", + "/var/folders/vx/lm_q_1ld7c13_fbqfscs9n4w0000gq/T/ipykernel_44312/692024527.py:3: LightkurveDeprecationWarning: The PDCSAP_FLUX function is deprecated and may be removed in a future version.\n", + " lc = lc.download().PDCSAP_FLUX.normalize()\n", + "/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/lightkurve/search.py:424: LightkurveWarning: Warning: 14 files available to download. Only the first file has been downloaded. Please use `download_all()` or specify additional criteria (e.g. quarter, campaign, or sector) to limit your search.\n", + " warnings.warn(\n", + "/var/folders/vx/lm_q_1ld7c13_fbqfscs9n4w0000gq/T/ipykernel_44312/692024527.py:3: LightkurveDeprecationWarning: The PDCSAP_FLUX function is deprecated and may be removed in a future version.\n", + " lc = lc.download().PDCSAP_FLUX.normalize()\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAt8AAAF2CAYAAAC28fR/AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAYJNJREFUeJzt3Qm8VWP7//G7lCZJIwkZUjQnQ6ZI5kqGVDKmiAdF5tRDxhKZZS5lSh7qiShKZIiIFFFKg0YZmhXq//rev/86z9rrrH32vPfaa3/er9d51dlnn733WWsP133d133dpbZv377dAAAAAMi40pm/CwAAAAAE3wAAAEAWkfkGAAAAsoTgGwAAAMgSgm8AAAAgSwi+AQAAgCwh+AYAAACyhOAbAAAAyJIy2bqjfLBt2zbz22+/mQoVKphSpUrl+uEAAAAgD2jPys2bN5tq1aqZ0qVLzm0TfLso8O7evXumzw8AAABCaPjw4aZGjRolXofg20UZb+fAVaxYMbNnBwAAAKGwadMmm8B1YsmSEHy7OKUmCrwJvgEAAJCIeMqWCb599O3bt1i9Trt27ewXAAAAkCyCbx9Dhw4l8w0AAIC0o9UgAAAAkCVkvpNsSbhhwwazfv16+38gG1QKVbVqVWZlAADIYwTfCVCg/dlnn5kJEybY4BvIhVatWpmzzz47Zh9RAAAQPATfCRgzZoyZPn26admypWnevLmpXLkyARCy5p9//jELFy4048ePt9936dKFow8AQJ4h+E6gf+OMGTNsx5Pjjz8+s2cFiGLvvfe2/yoA79ChAyUoAADkGeat4/T777/bzGP9+vUze0aAGPbdd9+i5yQAAMgvBN9xchZWxtM8HcikHXbYwf7LYl8AAPIPwTcAAACQJQTfAACgoFx++eW5fggoYCy4LDBapBdLnz59TJMmTUzPnj3NTTfdZI488siin23fvt1MnTrVTJw40SxatMhs2bLF1KxZ0xxxxBGmY8eOtg91SX755Rfz/PPPm5kzZ9rf3W233cx5551nDj/8cPvzefPmmXfeecfMmTPH/Prrr6Z69ermsMMOM+ecc07E4sLly5ebN954w/zwww9m8eLFZo899jCPPfZYxH2pRn/s2LF2oezSpUvt91qwqNtq1qxZ1Meo33n22WfNwQcfbG699dZiP//222/NSy+9ZB+r2v3VrVvXHrM6deoUu+7mzZvtm7z+Fu2cuv/++0f8XMdg9OjR9piqhrtatWp2Qa8eIwAgM/S5AOQKwXeBGTJkSMT3119/vWnfvr055phjii6rXbu2+fPPP4v9rgJvBZAffvihOe6448wZZ5xhA+Jly5bZYFzB6N133x31vhWA6v722msv07t3b1OhQgWzZMkS89dffxVdZ9q0aebnn3+2t62AWrf94osvmrlz55p77723qLWjfu+LL76wC2D1uPzqn7du3WrbQ+qxnnnmmaZMmTJm8uTJZsCAAaZ///7m0EMPLfY7CoBfeeUVs8suu/j+DV999ZW5/fbbzUknnWR7bf/99992AKD78qPAWkG/H12u29JxOffcc02tWrXs4ERfAAAgnAi+C8wBBxxQ7DJlrr2X+wXfykgrQ3vFFVeYk08+uehyZckVjMbKJDz33HNm1113NbfddltREO3NQHfq1MlUqVIl4raVTb/zzjttxlnfiwJnbTYjDzzwgPnxxx+L3d+OO+5onnnmGbPTTjsVXdaiRQsb0Cu77Rd8Dx8+3GbaV69e7RssP/LII3ZgcMEFFxRdrgy5H2Xb33rrLXPxxRebxx9/vNjP3333XbNgwQIzbNiwmDMGAAAgHKj5RtxU5qE2d+7A26EuMH7BrGPjxo3mk08+MaeeemqJGxO5A29va73ffvvtf0/cOHZ3VFcQd+DtPE7dnvu2HArutYnShRdeGDXrray0er3H46mnnrLHShl8Pwq+jzrqKAJvAAAKCJlvxGXNmjVmxYoVpnPnzkkdMWV4VaKhoPnGG2+0pRo777yzOfHEE219s9M+z4+CYtlzzz1TPlsqT1EJizcgVlb7ySeftH+f6q796DFrV1OV14wYMcKsXLnS7L777qZbt27m6KOPjrjuxx9/bGvib775Zvu3e6nURpdrwHL//ffbgYmOwSGHHGJ69epljw0AAAgfMt+Ii+qSpUaNGkkdMWdDmEcffdSWuKjWWRnk1157zX5Fs2HDBjNq1ChbnuJkwFPx5ptv2rKT008/PeLyCRMm2FIbLRot6W/QAkmVnuh6+hvq1atna9GdAYLodlTuotIU9yJRt/Xr19uA/z//+Y+dFbjlllts0D1r1qxidfkAACA8yHxnyD333ONbN5wqLcpTNjXbtKgxlU2GnN9XzXX37t3t/5s2bWr++OMPG4Bq8aK3lETBqbLCCni1QDNVs2fPtjXdqtlu3Lhx0eV6DFrU2bdvX1O2bNkS/wYtrFQNt8pnnL9BGW4t7GzUqJG97NVXX7ULNtu2bVvibUmlSpXs+XTuV4tQ9dxRdp3dVAEACB+C7wzJRYCcSU7GO9lOHE7ttXeBpYJXZaM1UFHbQTe1DlTLwbvuussOOlLx008/2dvRIs2LLroo4mcKvNWCsGHDhjbT7gT+KlHR9wqIVRKikhPnMTs0GNH3n376qf1ef4dq45XJ3rRpU1G7QScjrv/r9hR0y4EHHhgR8Du3rW4uBN8AAIQPwTfiDr7VgvDLL780559/fsJHLVa9tjfrrQz1lClTbEvAVINQ1aqrX/d+++1ns9ve7L1aG6psxK+3ti5Td5aWLVtGXTipLLZzm6tWrbK17QMHDix2vX79+pkGDRqY++67z5QvX77EAUWyMwwAACDYCL59KEDzBoPaRKbQqVxDLfMmTZpkF0p6A1D13daCQT9qMaj+3l9//bU55ZRTii5XjbOy4mp36FAZirLH2rgmWhu/eKlO+9///rftKKJstF9ZySWXXGLrrt2efvpp26pQnU+UFZeDDjrIZsD1mJ3BhP5ulbPss88+9nv96+11vnDhQlsD/q9//Stikx0dK3VX0eJL53Hptp3bAQAA4UPw7UMbyXgXyqlns7K+hUxt87777jtbDvL999/bEg5nkx0F5OXKlYsafIt2slQ9swJRBdW6rbffftv06NGjKNOrPuLqJNK6dWu7Y6Tux519d8pfVMLhnA+VwqjEQx1GRPXcalmoWnFlvNeuXWvvQ6Ucbk5vc7+FnCoLUXba6Ssu6oKiRaIjR460Qbcenzbt0e1qoCAaSLh/x02LM/Xl0MY/+ntVDqONjtT+ULt/6rimY3EpAAAIHoJvxE0BsmYFlAHWjpZaDKkFiMpaK+j2dhDx0hby+n0tSNTmMwpmlVl2b3mvXtqiXTT15S0BUVs/UUA9aNCgiJ873yvzrABYCylV6y0KcL3Gjx+f8NnXYkvVbKtDy7p162w2XztmuoPqeKnsRJsHaTCiQYkGL5ph0X0AAIBwKrXdabsAmz3t0qWL3RLcL/OtjLiCx3T0mwaSxXMRAFKj2VeVSgLZiCG96PMNAAAAZAnBNwAAKBhM+CPXCL4BAACALCH4BgAAALKE4DveA/X/+34zXYVc0+6b4u1FDwAAgo9P7zhpkxZtsDJv3rzMnhEgBm3a4zwnAQBAfqHPd5zUNka9rNWfeuXKlaZZs2Zm5513JvuIrGa8FXirP7mzwREAAMgvBN8JOPvss+2mKhMmTCj43S6ROwq89VwEAAD5h+A7Aaqx1S6Nhx12mNm4caPd4XDbtm2ZOzuA5/mnUhMy3gAA5C+C7ySDoMqVK9svAAAAIF4suAQAAACyhOAbAAAAyBKCbwAAACBLCL4BAACALCH4BgAAALKE4BsAAADIEloN+ujbt2+xnSvbtWtnvwAAAIBkEXz7GDp0KBuZAAAQQtu3b8/1Q0CBo+wEAAAAyBKCbwAAACBLCL4BAACALCH4BgAAALKE4BsAAADIEoJvAAAAIEsIvgEAAIAsIfgGAAAAsoTgGwAAAMgSgm8AAAAgSwi+AQAAgCwh+AYAAACyhOAbAAAAyBKCbwAAACBLypgA27Rpkxk9erRZuHCh/Vq3bp0555xzTLdu3WL+7qxZs8zUqVPN3LlzzZo1a0ylSpXM/vvvb7p27Wrq1auXlccPAACCZfv27bl+CChwgc58r1+/3kycONH89ddfplWrVgn97ttvv21Wr15tTjvtNHPrrbeaSy+91Pzxxx/muuuus4E5AAAAkG2BznzXqlXLvPzyy6ZUqVJm7dq1ZtKkSXH/7mWXXWZ22WWXiMsOOuggG4SPGTPGNGvWLAOPGAAAAMjT4FtBd7K8gbdUqFDB7LXXXrYMBQAAAMi2QAff6bZx40azYMEC07Rp05i15vEoW7as/QIAAADiUVDB9xNPPGH+/PNP07lz5xKv171797huL97FnwAAAEBBBd8vvPCC7X7Sq1evmN1Ohg8fbipWrBjzNsl6AwAAIBEFEXxr0aZaFp5//vmmffv2Ma+vwDue4BsAAAAITavBdAXeL730ki0PiVVuAgAAAGRSqIPvV155xQbeXbp0sfXZAAAAQC4Fvuzkiy++MFu2bDGbN2+23y9ZssR8/PHH9v8tW7Y05cuXN7Nnzzb9+/e3u1c6QfYbb7xhXnzxRdvb++CDDzbff/99xO0ecMABOfhrAAAAUMgCH3wPGzbM7lTpUODtBN/PPPOMDb5l27ZtEVvGfv755/bfmTNn2i+v8ePHZ+HRAwAAAFkMvpWx1uY2yXr22WdjXqdJkybFgul77rkn6fsEAAAAAlPzfccdd9jt3mOZO3eu6d27dzJ3AQAAAIROUsH3jBkzbFCtemw/KgFRX+1+/fpFlIwAAAAAhSyp4FuLGtetW2cz4No1cuvWrUU/W7FihbnhhhvMmDFjTOXKlc2AAQPS+XgBAACS5l4fBuRNzbeC7xYtWpihQ4eaCRMmmG+++cZce+215scff7Q12trC/dBDDzVXXXWVqVKlSvofNQAAAFBICy7Vqu/hhx+2me8pU6aYvn372svLlStnrrjiCnPSSSel83ECAAAAhb3Jjtr8tW7d2m7F7kzjKCPepk2bdD0+AAAAIDSSDr7/+usv8/TTT5uBAwfaMpOOHTua2rVrm+nTp5s+ffrYEhQAAAAAKQbfP/30k7nmmmtsb+1dd93VDBo0yPTo0cM8+OCD5oQTTjDLli0z119/vXn11VdZ2AAAAACkEnxrcaW2eW/btq156KGHirZqVxnKlVdeaVsMqhRF27vfdNNNydwFAAAAEDpJLbh0guwjjjjC9+etWrUyDRo0sJnwr7/+OtXHCAAAABRu8P3II4+Y6tWrl3idqlWr2npw77bvAAAAQKFKquwkVuDt1qFDh2TuAgAAAAidpPt8h5l6lpcuHTkuadeunf0CAAAAshp833LLLQld/6677jL5RDt3asEoAAAAkPPge/bs2TGvU6pUKdtmUP8CAAAASDL4fuaZZ3wv37Ztm1mzZo2ZOXOmXWipMo1TTz2V4wwAAAAkG3zXqlUr6s92220307hxY9O0aVNz22232ZaDJV0fAAAAKBRJby8fS/PmzU29evXMa6+9lqm7AAAAAPJKxoJvqVGjht0JEwAAAEAGg+8tW7aY+fPnm7Jly3KcAQAAgGRrvlevXh31Z3/++adZtmyZGTt2rF182bp1aw40AAAAkGzw3bNnz5gtBNVmsE6dOqZ79+4caAAAACDZ4LtRo0ZRg+8yZcqYqlWrmiZNmtis94477siBBgAAAJINvu+55x4OHgAAABCkbicAAAAA/ofgGwAAAAhS2cnLL7+c9B2oNrxr165J/z4AAABQcMG3gmh1MEkUwTcAAACQQPDdp0+feK4GAAAAINXgu23btvFcDQAAAEAJWHAJAAAABCn4njJlipk7d27mHw0AAABQ6MH3gw8+aCZNmuT7s7vvvtu8+eab6X5cAAAAaZdM8wgg5ztcuk2fPt1UqlTJhEnfvn1N6dKR45J27drZLwAAACBnwXcYDR061FSsWDHXDwMAAAAhw4JLAAAAIEsIvgEAAIAsIfgGAAAAglbz/d1335mHHnoo4Z9pe/nevXsn/wgBAACAQgu+V6xYYb8S/RnBNwAAAJBA8N2nT594rgYAAAAg1eC7bdu28VwNAAAAQAlYcAkAAABkCcE3AAAAkCUE3wAAAECWEHwDAAAAWULwDQAAAGQJwTcAAACQJQTfAACgYGzfvj3XDwEFjuAbAAAACNImO6tXr07pTmrVqpXS7wMAAAAFE3z37NnTlCpVKuk7GTduXNK/CwAAABRU8N2oUaNiwfdff/1lfvjhB/v/nXbaydSsWdP+/5dffjEbNmyw/2/QoIEpW7Zs+h81AAAAENbg+5577on4ftOmTaZfv35m7733Nt27dzctWrSI+PlXX31lRowYYQP0gQMHmnzTt29fU7p0ZDl8u3bt7BcAAACQ0eDba9SoUbYO/KmnnrJZby8F4/Xq1TO9evUyI0eONJdddpnJJ0OHDjUVK1bM9cMAAABAyCTV7eTTTz81TZs29Q28HZUrV7bXmT59eiqPDwAAACjs4Hv9+vVmy5YtMa+3detWe10AAAAASQbftWvXNt98841ZunRp1OvoZ7NmzTK77747xxkAAABINvhu3769XUx50003mddee82sXLnS/P333/ZL/9dlWpCp71mkCAAAAKSw4PLkk082y5Yts/27tfhSX37bt3bs2NFeFwAAAECSwbf06NHDHHnkkWbChAlm7ty55rfffrOXV61a1TRs2NAG3foXAAAAQIrBtxxwwAH2CwAAAECGar4BAAAAZDnzvXbtWjN16lQzf/58s27dOtOsWTNz1lln2Z8tXrzYLr7UZeXLl0/lbgAAANJCa9KAvAy+P/zwQ/Poo4/aft96IpcqVcpUr1696OfLly83gwYNMn369DHHHXdcuh4vAAAAUFhlJ99++625//77TdmyZe3CS23H7h1JHnLIIXaLdu2GCQAAACDJzPeYMWNMmTJlzJ133mn22Wcf3+vo53vssYdZsmQJxxkAAABINvP9ww8/mAYNGkQNvB01atQwv//+OwcaAAAASDb43rp1q6lcuXLM623atImDDAAAAKQSfNesWdMsWrSoxOv8888/9jq1a9dO5i4AAACA0Ekq+NZiSrURfOutt6JeZ+zYseaPP/4whx9+eCqPDwAAACjsBZedOnUy06ZNM0899ZT5/vvvTatWrezlCrY///xzM336dDN58mRb892hQ4d0P2YAAACgcILvKlWqmDvuuMMMHjzYfPDBB7bnt8ycOdN+qe2gOp3069fPVKpUKd2PGQAAACisTXb23HNP8/DDD5vPPvvMzJo1y6xatcps27bNZrubN29ujjjiCLPDDjuk99ECAAAAhbq9fOnSpW1Nd9jquvv27Wv/Nrd27drZLwAAACCrwfecOXNscNqwYcMSr7ds2TLb57tx48Ymn2jHTu3OCQAAAOQ8+FYtd6lSpWzXk+uuu86UL18+6k6Y77//vhk3blyqjxMAAAAozFaDouBbnU2uv/56s3r16vQ+KgAAACCEkg6+jznmGNtGcPHixebaa6+1pSgAAABBpo5sQF4G36r5vuSSS8yVV15pNm7caAYMGGDeeeed9D46AAAAIESSDr4dJ554ou35rX7ew4YNM08++aRtOQgAAAAgzcG3NGrUyHYI2WuvvcyECRPMrbfeajZs2JCOmwYAAABCIy3Bt9SqVcsMGTLEHHbYYXbTHfXKXrlyZbpuHgAAAMh7aQu+RS0H1Yawc+fONvCeO3duOm8eAAAAKLw+38cdd1yJG+ycd955pm7dumbkyJGsKgYAAABSCb6vvvrqmNc5+uij7RcAAACADJSdAAAAAEgx8+1soFO/fn2z4447JryhTuPGjRO6PgAAAFCwwbcWUWo7+ccff9zUqVOn6Pt4jRs3LpXHCAAAABRO8N2mTRsbbFesWDHi+0zatGmTGT16tFm4cKH9WrdunTnnnHNMt27dMvq7AAAAQE6D72uuuabE7zNh/fr1ZuLEiWbvvfc2rVq1MpMmTcrK7wIAAACB6naSDdq05+WXX7YZ9rVr1yYUQKfyuwAAAEDBBd+plLVkuiQGAAAAyFjwPWXKFJMKbcqTT1QzHo+yZcvaLwAAACBtwfeDDz6YVDZ5+/bt9vfyLfju3r17XNdjEScAAADSHnx37dq1oEo5hg8fXtTZpSRkvQEAAJD24LvQWvQp8I4n+AYAAAASwfbyAAAAQJYQfAMAAAD50Gpw9erVZsaMGWb58uVm8+bNdoGll2rFe/fundTtf/HFF2bLli32tmXJkiXm448/tv9v2bKlKV++vJk9e7bp37+/rUvXAshEfhcAAADIi+Bbm9hoC3d3wO3831mc6XQ7STb4HjZsmA3wHQqenQD6mWeeKQqgt23bVizwj/d3AQAAgEAH39OmTbPBt3aS7Ny5sw1qv/76azNw4ECzcuVK89FHH9mMdMeOHc2hhx6a9IN79tlnY16nSZMmZvz48Un9LgAAABD44Putt94yZcqUMXfffbcNwL/77jt7eYsWLey/p5xyihk7dqwZMWKEadWqVXofMQAAAFBICy4XLVpkDjzwQBt4e8tMHKeffrqpU6eOefXVV9P1WAEAAIDCC77/+usvs8suuxTbbGbjxo0R19tnn33M/PnzU32MAAAAQOEG39WqVTN//PFH0ffVq1e3/y5evDjiemvWrLGLIQEAAAAkGXzXrVvX/PzzzxGLHlVy8tJLLxW19tOiTNWC77XXXhxnAAAAINkFl+pg8vnnn9sOJ82bNzcNGza0Abg6nGgr+goVKtgSFNWCd+nShQMNAAAAJBt8t2nTxgbcVapUKbrslltuMcOHDzfTp083GzZsMHvuuafp1KmT3dAGAAAgCPw2BAQCH3xrgeUee+wRcVnFihXNFVdcYb8AAAAApKnmGwAAAEDiCL4BAACAIJedOG0F33jjDTNnzhzz+++/m7///jvqdceNG5fs3QAAAACFHXyrq8ltt91mN9tRR5PKlSubcuXKpf/RAQAAAIUefI8YMcIG3p07dzZnnnmmXWwZJn379jWlS0dW5LRr185+AQAAAFkNvhctWmQaNGhgzjvvPBNGQ4cODd2AAgAAAHm64HKnnXYyVatWTf+jAQAAAEIsqeD7kEMOMfPnz7elJwAAAAAyGHyff/75pkyZMuahhx4ymzZtSuYmAAAAgIKTVM23tpW///77zc0332x69Ohh6tWrZ6pXr247n3jpst69e6fjsQIAAACFF3wr2z148GDz888/m+3bt5tZs2ZFvS7BNwAAAJBC8P3cc8/ZXt9169Y1J510ktltt93o8w0AAABkIvj+7LPPTI0aNcyQIUNM+fLlk7kJAAAAoOAkteByy5Ytpn79+gTeAAAAQKaD73333desXr06mV8FAADIGa1VA/Iu+O7atatZsGCB+fTTT9P/iAAAAICQSqrmWz2+27dvb+69915z7LHHmmbNmkVtNSiNGzdO9XECAAAAhRl89+vXzwbamrqZPHmymTJlSonXHzduXLKPDwAAACjs4LtNmzZRs9wAAAAA0hh8X3PNNcn8GgAAAFDQklpw2adPHzNo0KD0PxoAAAAgxJIKvpctW2Z22GGH9D8aAAAAIMSSCr533313s379+vQ/GgAAACDEkgq+TzjhBDNnzhyzdOnS9D8iAAAAIKSSCr47dOhg2rZta1sOjh071ixfvtz89ddf6X90AAAAQKF3O+nYsaP9V32+hw8fbr/C1Oe7b9++pnTpyHFJu3bt7BcAAACQ1eC7Ro0aJsyGDh1qKlasmOuHAQAAgJBJKvh+9tln0/9IAAAAgJBLquYbAAAAQA6D702bNpnNmzen6+YAAADSTuvVgLwrO3F8+eWXZvz48Wbu3Lnmzz//tJeVK1fONGrUyLRv3960bNkyXY8TAAAAKNzg+5lnnrGBtzOCdBYoKgOuoHzmzJm2JWHPnj3T92gBAACAQgu+p02bZv773/+aKlWqmC5dupg2bdqYSpUqFQXf77//vhk9erQNzhs0aGCOPvrodD9uAAAAoDBqvt966y1TtmxZM2jQIFte4gTeTgZc/bDvueceU6ZMGTNhwoR0Pl4AABBSih80cw6EWVLB96JFi0zTpk1NnTp1ol5HP9N1fvrpp1QeHwAAKBCrVq0ya9euzfXDAIIXfGsr+fLly8e8nq7DtvMAACBe27Zt42Ah1JIKvmvXrm3mzJlT1OHEj36m6+i6AAAA8aAVIMIuqeD7qKOOstNCquteuXJlsZ+vWLHC/mzdunUstgQAAHEj+EbYJdXt5IwzzjCfffaZ+eqrr8xll11m6tevb2rVqmVKlSpl67XmzZtnp43q1atnTj/99PQ/agAAEEqUnSDskgq+tZHO3XffbUaOHGneffdd8/3339svx4477mhOOOEEc8EFF9jrAgAAxIPMN8Iu6U12KlSoYHr16mUuvPBCs2DBAvPbb7/Zy6tVq2b222+/uBZkAgAAuJH5RtiltL28KMjWdvJAMrQwl4EaAMBB8I2wS2rBJZAuWrzLFCMAwEHwjbCLK/P9n//8J6U7Oeuss1L6fYTT33//XfRGu8MOO+T64QAAAoDgG2EXV/D9/PPP204m8XCymO7rE3zDj7MB08cff2xat27NQQKAAqfYIdPBN7OtyIvgu2vXrnEH3/L777+bKVOmmK1btyb0e0HRt29fU7p0ZEVOu3bt7BdSe8PTsb3oootMgwYN7PNDbr75ZhuAAwAKmz57s5X51mdSPsYoKJDgu1u3bnHdmDbVUYnK1KlTbWClhXSnnnqqyTdDhw41FStWzPXDCBU9J+68807zxx9/mGnTptnLGjZsaP/dsmWL+eWXX0zNmjVz/CiDZfbs2XZ24KCDDrLfL1++3Kxfv94OXAAgjLIZfAN52+1EFBC8/vrr5q233rKBlPp8ayOeM88801SpUiUdd4E89tNPP5nrrruu2OXfffdd0f+/+eYb07Zt2yw/suDSZlXdu3e3/3/zzTdN//79zcaNG838+fPNF198keuHF/hj58xSffTRR+b+++83t9xyS64fVmC98sordnYTCAIy3ygEKQXfGzZsKAq6N2/ebIPu0047zXTq1ImgG5ZmQM4+++yYR4MavEiXXnpp0f/bt28f8TMF4ZUqVeIZ5vNc0667V1xxRUQ3HdE+BArCUdx9991H8I2CqvkG8rLVoILuF154wfTs2dOWmahrhYLup59+2vTo0YPAG0W0EVM8FDTh/0yYMMEsW7Ys6uFw7yaL/zniiCMiAm+3Dz74gEPlY+XKlUXv6RrU6V+UTKVzmlFx/PDDD6ZNmzYctjRR56ts1nzng59//rkokYACDL715vziiy/aoHvMmDG2HlVZuWeeecZeVrVq1cw9UuQdDcRUtxyP0aNHF7UeLHT//ve/Yw5o9GaM//Pll1+aTZs2xTwcDPCKBx7OrMqxxx5rjjnmGPvvwQcfbKZPn87Ty2dDMB2fzz77zFx99dVFr9Nzzz3Xll4m0uEJ0ZH59n/u6QvxmzNnjsn74FsfbC+//LINphQk6Q1ECymV6b7kkksIugvQAw88EDNLNmvWLN/LnYWWXhrYIT6nn346h8o1GFHpWyx33HGHzVri/4wfP77E1+63337LoXLReia95znrBzRDpYFKIg4//HDzzz//cFwDkvnOx+cg/Gk91MUXX2y7p+k1pq5qeR98K+jWohwF3VrIpKBbH3jVqlXL/CNEIClQXr16te/P1qxZ4/uhdOCBB5oZM2aYkSNHFl323nvvFf3/kUceMYXupptuivu6ysC98847ppA5H0aDBw+Oed0lS5aYPn36ZOFRBZ+O1+233x7153qPv/DCC7P6mIJu7dq1abmdQsx+K4GnjldK1n3yySf2MyIoCy6DSLPAmokS7YHhlNN16NCB0rAozjnnHNu44d133zWHHXaYCcWCS5WbaCpIo4lJkybZr3jp91577bVUHiMCavHixWbfffeNe7pHAbnTU1VvwvqA32WXXTL+OPMpkHQPRkTtOhVgq42n1lW4OW/IJ598silURx55ZMT3FSpUsB9Q6rCjDjFqz3j55ZcX/VzZXNXT16lTxxSqpUuX2rJBJObtt98u8ed6f3vwwQdj1uYq+NbrupCeb+p+5i3/0nud3/t/IZedqJzw1ltvLZo11nNJ5SZOWZ0Wjqv0SUks+pMXSM23Roh6QeiNI5EvZyMVhM/111/ve7m3raDeeFWu5M6kuRdiuhcvFfJiwuHDhxe7bPLkyWannXYyNWrUsJmQRx99NCePLYiUQfPStGPv3r3NkCFDbIB9yCGHFGvN2LFjR1Oo9J7sDoRiUUCplqCFmK31iicgjKejTiF9Jmr/hmjPt+OPP9537Uohb3yjpJS7XDNanbe6y+F/71H5uAYqrsz3f//738w/EoSCt55Rbcw0UvfjBEXuLNB5551nX0xPPPGEKTRauOxVrlw5+6/aeDof7Mcdd5zdQdah6dxoxzjMFGS77brrruaEE07wzSq+//77ER0pNJX74YcfmkKjGZREXXDBBea5554zTZs2NYVIWUeVQjz77LNxZXnVQWa33XaLep1CGMhooX29evVshjbW2hW9NitXrhwxyFHddyFRwkrvTxqsxEPBNxsB5vcaqKRaDQIl1SG7JRMUFuImMn6L25ydQL0UfLtnF/T/ZIKqfOa33kB1fnvssYfv9TV74BZPd5Qw8ttxWB1Pdt55Z/v/yy67zPf3FHwWqn79+iXU5s3bl78Qg29tEHb00UfH7NwkCjrdtdfZzHwHpeZbg5WJEyfGff2nnnrK93IlYgqlq9O2bdvyugNM4b6jIuMdFBJZPFjICwf1BuIuyRk7dqzd7VP1y35U4+3dkVABeSHx9u3u27ev7fMdjT7Mvc+xQuw64f2b99xzT3PDDTfYGnAF2Jph8escU6hlAOqO487e6ng5ay/q1q0b9fe05qBQy05Kahm7zz77+F5+5ZVXFpX16N9Ce75pEOBXRheN9lfRTIw3+Bw1apT9/CgE99xzT8SgWAM9J3mgYxlrjUauEXwjbRYsWGBXGjudS7TTabxU01yo3L3QtRuosrfxdO8oVPpwdx+fl156yXTr1s3WkCbyHAv6m3O6eWtv33jjDful6evq1avbhaoNGjSw5TtehVYGIPpg13PK295Ng5RGjRrZAEjdczQQHjduXMR19DqO1vs7zJlvDSx0XPxohk6DvE8//bTYTIpmTEeMGGH/r3aO2Zr9DErmWwsp/Tz++OM2mNbx8Jb/Dhs2rFjpnAbPYX5+uem9y0v7zehY6TjUrFnTBBnBN9KmS5cuERmiVIIDLZwrFO4Fp8rgxkt9qwsxk9uqVauI7xPJkrmP9W233WYKieqRHepS5H2NDhgwoKhFV+fOnW3NrnstxkMPPWQKid+UttawnHjiibatmZx//vk2qNTiXnVv8m7+5CfMwZHKwbTY2a/cyZmtK1u2rPn88899A01HIlngsNG6FVEQeeihhxaV0u2+++424PaWRM2dO9cOEJWUKFOmTKifX6I1YSpr8sq32V+Cb6SFeii7Rau9LYk2r3AWHapfZ6F8wLs3F9IHU7xOOeUUU79+/aLv86G3aaq82UQFhSVN/3sVUou3aJ06NMB79dVXS7y+SlG0t8PDDz8cMaVd6Pbbbz8bEPm192zRokWJXZ8KoezEL/DTgNevp7wy5N4SCb9sZiYFoaWhe9+LSy+91JZTuJMEbu4BsUMDQA2WVYai4LsQkjCzPTtnq8TVu64n6Ai+kRZnnnlmWjKKzZs3L/p/2EfwylS4a9aSmWq99957i2VCwkwfTO6FWtrmW1OMiXAf56BMO2eSPowVMDpUohMvbx29eqQX6u6f2mwuFpVAxRLW9zWVi7gHaBp8KLEQbcCrQbM3SXPXXXeZxo0bZ23vgiAE3+4Bbq1atey/0Y5Z1apVfXeI1utSi+5VzlMIwbfbk08+mVCJa1AQfCNl3hd7rNX+8fKbWgqTdPQ014fXSSedVPT9xx9/bMLMvcGXs8lQKtQHXLWU2kgsrNRW0ZHq5kLqkV4IPYYHDhwY8b1mAdybNUWjmSj3egRvO8wwB9/qbOWuS1aZidYQxOJNOmiTNnXtKJTg26H2uvF8dmqvB23E46W9NLQ2I0h/U6qGeEqY3KVzjpYtW5p8RPCNlM2fP7/o/9OnT0/bEQ37hjsXXXRR0f+9C7YSceeddxb9X0Gk+gyHnaar995777R0S9GUuDYwCmM5gDL77gWDfjvSxuLNtKXyXM3Xza/8pvujUaeikmqXw/g880pkI6do5XjZ2Dgl14Gqu3xCtcwqG4lFbUG1ONrPqlWr7ILWsBg9enSJzyv3Z1++IfhGUpzRpoI91d064nnziMWdnSupbVWYpJKR9C44TNfMQ9CCSHdQk8yaArdKlSoVuywfd0mLxb1bnpx11lkp1aRKomU++b74rUmTJgn/nrv+25vpDmPm29v6U+t3EuG3GU82jlMug+81a9akNLurQFQtGt3S8fkbVAcffHDE9zfffHPWypMygeAbSVHtmShjmG6vvfZa1M4WYdxKPh07leXjDl+J9lteu3ZtqLNg6abuJWq95VALwUQ2i3Fz9/6+++67fXdjDQstYPNbY5BsHe/hhx8e8TPt6Bg2zz//fEq/rwTCNddcE3FZNhbd57I+2r14XNvKJ0oDHKfnfLTBdlgdf/zxSSUSgoTg24e6AfzrX/+K+PLbeAKR0tWbNZGOH/lIdaCPPfZY0ffp2ObcXfcdRu6uCOmaVg17O0tvH/N4dhuMxtv7W/WpYaXWbamKtkGWTJ482YRtoaU7UH7uueeSup1zzz03ov2lt5VqmAbcWhypXvCOXr16JXU71apVM1OmTDHlypUzhWTQoEEm3xF8+xg6dKjtOer+ateuXfbPToBlukvEtddea8LKXQd6wAEHpOU2tXAwrJSdcg9W0jU48y6g8+4aGjaF0IoyqKVk+Z6lK8miRYsivm/atGnSt+X9nM3050yuMt/eDXNSoRrwVGcegr6m7NxzzzVhQ/CNpHjfFNX2LZ2cTSy8ZShho5XrmeC3Kjxfvfzyyxm5XU11x+p3na+89evOtsupcHYgdNdglrSNer5nvd3lJ8lw//7ixYvNpk2bTBifZ+6F494Sm0SpneO0adOKvvfuLhqGzLfWMT344INpvc1EFgTnm08//dT88MMPRd9na/fTTCP4RlK87cb8djVL5xRTWOpxvdNlu+yyS9pu291pJtVuA0GZ8teOee4PKu/CrlSp+0fY+n7rb3BnilSy4679Tpb6L3tLV6JtoZ6PVDrhDpi1dXwqlO1W6ze/lo9heT/TWgz3jPEjjzyS8oBYJTv777+//V5rFNzdtNItF+fBvY5Jm1m98847abldd2lYmAZ6k11lWmEJvIXgG0mN3DUadbKG2vY204FqtN3i8o07i69tqtPJu9I9HzvFeLON2pbavQGTX5eSdFL5TjoC1VzPFLj7lqfaGcbNu8BLO8uFxbffflv0/2it3BINJL0b8zgL1ZcvX27ynd5f3Fnv6tWrp+223duou3v753vZiTfY1+Z0NWrUSMtta/ATbb1HWF6XYULwjYQ52cG99toro2UhWtGczkWJQdu4Q10j0k2Lgx0PPfSQySdOX/fff//dPscmTpwY8fNMdthwZ6O+/vprk8+0SUm2NqDQzEQYWufpb9D23I54NtSJh7YL79Kli+8ixTDRIHmfffZJ2+25ZwTdnaHyPfPt3mlWJTrpbA2oDY2cwVC6sunIHIJvJOy3336z/2pKVW+6hdT3N91bVqebOngom5LJWulMcbZUVm9lZQzdvYIz3c81HTXRQaBBiztTmGoZgB9vb2G/3fZymY1NZnG8AiGnhOKggw4q2uY7Ha6//vqi/2tgGYbde/U8cycTtPNpOlqmurk30VqxYoUJW6vBTMwaOa/Nr776KnTbzL8WsrVfBN9IKDukDyjnw03TqtodMJP8+ldr97N8995772XlTT2f3oDdj9Xb4zfTC4qcGtN8590VNhMDY3epgbNZSJCeQ9rlL2i8ZSz5PlugwYO7tEEDlnRzDxwztY9BNjPfY8aMSdvGavF4991383oNy9+usslu3bqltKNxEBF8I25qZ5TuOuVEWg6q3lRbpye7UUguefvEp3OhpVfp0qV9S3eCLtpA4eqrry4W8KVbWPrkumvmM9nH3B3Uz5w50+QzZW3dMnHctLDO64UXXjD5SAMHd2mT3y676bDbbrtFvDdMmDAhr4PvwYMHZ2zhuN+gpX///ubpp582+fj82rhxY0QpoPZeCRuC7wBQJjcfsrmqu852jZx7swotUsrHrdMVALun5t1vwpnilHAEqRvFsmXLSmwdFi34Pu+880w2uFfSq/Ql33iPk7JFmRLUmtJEM33aolrPS7dM7Krrt+mOtx1kPtDxdZfRRBtYpIMC+nvvvTdi857PPvssrc+TbH2eeXfnzeTCcXeG+KmnnrJ/az5lwF988cWIHT+zUa6ZCwTfAaCuHpku30jFuHHjbOb2u+++y8n9awQflnZc0rZt24zfpzuzEpQAXBnGkjoXBKE7i9MaTrW5+bQoTj233SUnWjyYydkVbewRRIkGU5qad8tkKzNnVuLOO+/M2xrWBQsWmI8++ihiENa5c+eM3d8xxxwTsZlPKru0+slW8O1+z890uzxvoK2scT6t/9myZYuZN29e0fe1a9c2YUTwHQDqyRnkD3p9QHmnybLZb7NRo0YmH23dutUGRbnYFtfdXzgTi+6SVVINut/PMjHVXBJt1ew49thj8zI7KU2aNMn4fbg33QnKcyyRYMqbTMh020QnI+nucJFvLQe9+zukq01eSe9j7tfkr7/+mtZZ4myviVEmOtuvAW1alE8lTju4PrvCjOA7IE+2IG+6oO4m7jfAbNNiuHRux5stasPmlc0abKeO+fXXXzdBUdL0pzfzrSx5OrtOxMM7HRyEbHwyHQ/cdf+Z4r4PrQeZPXt2USekXElken3dunUR32e6pM0JKtyLE/Oh3NDN3aUlE3XefipXrhzxfTrX/GT6c1elX+4ETCYWpnpVq1at2AJfv8+ioHriiSciEiBhRfAdAKpjc+9OGDTuKSC57bbbsv4YvBv55MOHljer5X5TyYaPP/646P+PP/64yTV9WJcUHLkXparUSR8iueatbw0ib1lRturVvT2KFZjluhY8keDbXT+s14ezTiJTjj76aFsO5H5eq2QjH97LvF1tFERqo7VsyGSQn+nMt/ezMxvU8lFrjPKxrOkfz/no16+fCSuC7wBo2LChCSq/zIB718FcyfWHfDxvuu4NbzTd6C1ByeagRYuVgh58a2GNajw1SMl0G66SuGcnfvrpJxN0bdq0iSg3ydSOs34zUkH7cEwkkzlq1Cj771VXXRWx+UmmVKlSxTRr1sz+390j+5dffgl860EdV3evfb2fpXODmFj23HPPiO/TtY4lk5nva665JuL7zz//3GRTPrbmu82T2AtCAqbggm/VQWtnqwEDBphzzz3XTqO89NJLCdWmqc3OhRdeaDcd6d27d2B3Sdx3333tG3MQ+e2SmI0pbT/uoN9ZtBREekO/8cYbi75XP9xsTDf6CULGO97gW7S2IBeDFLdzzjkn4vsgdwrwZorUJSBb5QC6H2dDp6Acq3jv3z0rpc+IXL6X6ZxlchfHdMj2rJ2X9/ho4eebb76Z8q63mQq+td5HtdbuTZxy8bnpbtGX6/fVWAYPHlzUO17xXpCrAUIdfGtkq+2llRFIpvWTtu6ePHmy6dq1qx1NKUszZMgQM3XqVBM06pnqbUUUpLY/uVpo6aVtmt01h5na9SzVldpnnHGGWbp0adFlNWvWzNnj2WOPPSLefOfOnRvI4DtIHwxOdtIR1Nemt82byij0IZ9tI0eODEzwHW8wpT0Dcsk9QFI5h5JNQeaeOWvatGnW79/buadnz572cz3VftmZKjvxlqsp+ZcL3k40QV5bNsa1CZGSV9mcWcmFwAbfWmil9jjqDnHBBRck9LsKEL/++mtz+eWXm1NOOcW+WWhqsXnz5nYEHbRd/7y7+QWFd6CSyMxDprqenHXWWYHe3EObA7j7BlevXt0EdROWVKnDRSLnQIsXNaB2gjQNjvUVxBIsdzu1INdOuoMPLejLVtbbO3PnePDBB81jjz1mciVW8K/gw70AORvlJtG4Zw28LQ+DxBuw5aqEzZ1JTlcwmalg1L3eRkmjXO2gqwDWHT+5N60Lki+//DLi+0yvvwiCwAbf+hBJ9oNEC0G0qYF3VbRqObUaPxeLIOIRtPrS6667LuL7+vXrm1zTrmdOS7D77rvPBIkGfN4dQJ1gM5ec2tZ0e+ONN2yHi0SP0Y8//mhLO5Td0Je7P/Utt9xigsD95p/rKfdodBzdHU5yeaxUHujIZXlfrGDqvffes7OijlwOFNzB96pVq0xQaaGoezFfrvhtVORtfZiodCfilGBQAiZIi7bdWXe/AUyubd++3fTq1avo+/vvv98UgsAG36lYvHixnW739ot0FiDo5yXRFGA8X+leJHP22WfbLg+5pDcP9Tb29lcOUgbX2XhBpUlBagXnzQjl+k3XceCBB0Z8n67SANUwJpM5UimYO3B0L0wNwgDPrxvGYYcdZoLGve5B7x251LJly4h63FyJ9dz2LhDNxUyBX0mYeIO2INDCdveutLlu+erdHXjJkiXFNjHLZeZbJbLujYGCuEGcAl33+2+unekahNatWzetrSSDLJTBt4Iyb29QcS6LtVJadcWaKor15a5RSpdcZ3P15qFMqXsnsYsvvjgQGVy/+r9MbAWdDA3EPvnkk4jL9BwJ4iyG1j5IKh9aosFtOjJHTr/lbC4WjId78K6/013HHwROtlSLzjK5XXW8geRJJ51U9P3YsWNzMsPoBN9+iREt0HPTY8ylnXbaqagXfxA7OCkwdQePKgPN5K6p8e4UqeOWrr0TMlkDrc5Dp59+ugliiYcSIEEwatSoiPfVHj16sMlOIVNd+OjRo2N+ZSLblOo0WiqcN6L//Oc/EZerdj5IvDMauVpE62Td9a93tzzvB32uud9sX331VVvqkeqGP4lmvqPtuuhspOOeegwKDQgcWkgbxHKAsmXLmiBwD9iVlc9FMOk8H/0WyXrbmHkzz7ngLoG55557TFCo97i3Hj5Xdcteel49+eSTKTcC0EA/ncG3dzF7kM6nOr/dfvvtgVvk/pCnm1oQ2hhnSygz38pw+2W3ncv8suJuqmuL5ytdH3rKwHhfGLngl8XUArggZSOdoG/YsGFRa9OTkcwbkbLu6n2rfzVid0+NqjY9aNyDqvPOO6+oJVa2dmaNdkwUKOV6xieecoqg0OtUz39leTUg0FRtELizuN4uKNniPB/dC2bF25IuWxvExOIuUXA6XwWBd+r/iiuuMEGhNQbe12Uy5zPZsjkvdV555ZVXii1mD1K3jhYtWkTsBxAEH3leowcccIApJKEMvlXbrbplbzDp1HoH5cPKnYFxvzC+/fbbnDwOv/vNxQdoPA455JCI73PVwca965t7ajSI/J73qZQGpKPsRM99vekGdUMIv0FZLtvpacG4BpvadESLU/XlnYbPJc2q5JJzbpR5nzFjRlF2zbtoNiizBaLAzaEFyB07dszp4/F7TXsXkgeBeyZKa6WUrU9kHVa6yua0iNybPFCHpBo1apgg0YJVb097vb+lWn6Y6PuXNmhatWqVufrqqyN+NnToUFNIQhl8KxOp8g1vDa7ammnHpCAt6vJbyZ3tTR/0AtSbhUbwbkFuf+Xd/crbsi5X3H3I8yGY1AdHspQ5SuTDyzuDstdee9npY73pBm1A7ObuiKHXRLa2b/fSudKCQWUh27dvb4LI3XYwF4uO3ZlMlcu99dZbxbr95LK9oJ969eoVBbcKStytSnNdPuTIda23H22+51AAqWy9U0o3a9asmIO0ZDPfal+s9z3tUhptxjSoyQS1XHYGpY5Uyw/jpUWel156qQ2+27VrFzG7rue/U35YKAIdfKuOS/0ynSeLVjbre31plCtqdaZMgRaDOPSCUE9v7e6nhYLqo/3oo4/ansQKjrw1w0GUrU0XnC1v1U/dK0jTZn7cC6YUlETLevz+++9pu089j1auXBn1TTeoWW+HNwPoLt/JVNmJjpWCIL356vWo4EeZR23gtOuuu9rdXYNW2uTm7nRy8803ZzVT5AQKCiA1QFaGTcFakLmnk99///20bQUeD++sxK233lrs9XnssceaoMvVQj0F/t7F9XqfzWWLwWg0YHd/7rs7xrjLAKM9TxRDKKZI1C+//GLuvfdeM378eN+fp7rrZqbpvdbdhzyb644WLVpU7PKHH344Yu1DoQh08K3AQEGhU5SvJ4y+15d7QY0CAO+broIxlXLoA15vwD/88IPNwuTDG6/fFteZ4m7z5qZp2yC+4bp5H5929/NbeJPOTOWIESOiZh31IZUPdWsPPPBA0f/VRizZ7HcimW+9BhcuXGgDdg2KnV78+SLaYtFMU+Cq9zINVu64445AlZhE490gw29gnymxSoK0HsO7618QeB+3yiazHSAp4eMtedH7qUrDgjg41mPSQDTahiwlrWdxjrdfMOjHm0n3NiUIalveeNdn5GrxZbt27QI5q2IKPfh+9tln7ejS70sZM+dDUd9369Yt4nf1wa4pDtUsazMQ7cbXunVrE2Tutk7KQGSytlQvtmidVXbeeWe7kDAfZgi8m2RcdtllNsjLRDavpA4mGqwEoXtCoptmiMqNksnWJFMzGaS+7Il2QEq1u0Ki1JFG9d16b1PWKIgBUDQqKXJks01pSTMx2ThnyVIpQ58+fSIu836fSfq8Cfrnox+9JjQb6bZhwwb7b6z3JpWGePdAiMbJpMe6Te0NoPUY+cD7eeZ9j8uGgQMHmkIV6OC70HinGr2LCjMdhIk+7HO9kUIi/DY/UWbLve12OmhxiLdVmTNzoA91DVbyiXezkWR2cYxWM6kSE20zrsWo3oxK0EuZ4qVBnsqZMrHQV4NuzaJoQKRMba6y7qnQ+XfTFtepdNaJl+4jiIsDY1Hg6+2WIfPnz8/K/Xsz3kpuBXmw4qYSU3XzcDiz2yXtGK3XmLK/moVLRLTNtvT+qeOVDwkrhze5p0TWXXfdlZHdhv023hqVoZ2X8wXBd8AocMn0dFBJ2z8rw5YPU9ux+nwnswDTvZOb2xFHHBH1d7QBUT5y7yrm0OLHRDLg+qDxG+Q8//zz5oUXXvAdkOTzFKN3UKpypnSXBqgOVeUlGriorjRfj5cy3+7gTX3w9TpSOUWmS6omTZpU7PJsLSpLlbqdZLv80G+Bp8o184lmtv2OpdZ7RQs8E30uehMN+hzVIEUz1kHomZ0otX717l2gKoFMzFi5N5xT4mLixIlxzzqEFcF3wDjlNG5axe3sApgKvRHpDadv374xW17lE7/BwoQJExK+nV9//bXYlJj68Ppl7NRJJ18yQ9F4z7c2YkgkA758+XK7+MihMiZlknR5GO2+++7FBq56nqWrNahaoeq1qZ0iVQqkmYWw0XMjE7MFeo1q8ZwW1TtlHE5HJC3Ky2bdeSo6derkG1hmqlxL2WFv1luzfPk26FPdt3dtz4oVK4oaCvgF3yV1PfPb7MVZzOlec6RkWRB3sYy3ZEfZbe8mepr9dhJR6Xjeqb2ge3Gl3tuq50FdfKaF7909BLzTMcqGOZuipEJZ2mhvFCqpCHoXhUSmuUVZyXgX1Hin4dTRQmsJvG+4Mn36dLPjjjuafKfz7d7BMVHe4FCZ8+eee66oE1GsTRXykXeR73vvvRe160EidDv333+/fR1Gm9rOR0ceeWSxMq10d4PQ61ZZdfdsjmYPNDhWFjwoOzPGGxB5W7xqJkntc9PZZUeDFd2e3y7Np512mslHfjtKKpng936k54y3D7cGbk73k9WrVxf7HfdeHPk2M1ASb2cYzSQ7r9vXX389pdvWYn53GVhJs8iFhuA7gPymY+LNJmoRhbtOUO33li5dWmL9m6aBgto3ONkd2ZwFS4ls+qHd5TR9qHrbkqapw1K3HG1L95KeK379kvXc1PNMpSbRKAiK1pUg36kFoHsGQOKdhtZxU/tAPffU7zxsvW69G2k4Myx+278ny2+AnM+qVq3qWzqTykDZS++L3vc4NTjQgEUL7vOVNtvx0roJP94FzGrQ4H6+lvQcbdCggQmTaOu8vGWw8XD/jnfvEPwPwXdAvfPOO8Uu0we6s5K7pAzwtGnTIrK0quvyy3A4b/Sa5g4DfXB4BxGJBN/OAhN1Likk3vIZPVdUL6mMW0mcXQKVKVObx2i0iMe9IVIYaa2EU54Ub1mF+sWrzERbZetDP0yDOsc+++zje/mQIUPSEnQrq+ldd5DNLiGZoteLBnXeQbF7b4NkafbBb6awWbNmJow0M+Wta1c5hTNzp9nR22+/3f7f3fdbPeH9WvF6yzTCUlKnDbJuuOGGiMuTKalzeutrJg/REXwHVLStaaO1B3ToDcUpn1Dj+muuuabE62uBRb60RoqHX0cScUoDtGjGu7By7ty5SbWDDBNvVk0LVv0WMakuXkGPBjXx1NVrA52wDO4cGtyq5t/dLUhZMk2paqGkMz3tbYPppt/XB74+7NzT2WGkXfX8kguaLYiVTHCOo3e3YrWQ1XoMzXh5N9LJx24n8e6SqMRAIqV0fgkcvzrofKmJjyeI1Hu9971Lde0auPTu3bvoc8ApHVSdfbTMr46VexZLt5Gvi+xj0Xu6Xw98fRZ4X3/Rygr1mhQdM+8GSEHfMTvbCL4DzG9Bn9qbDRgwwHz11Ve+v6Osm4IjBeCx6rWUFc+3zibxUK23N9OvxZMKjDQL4H2D8Wvx5aasrt5Y9Eacr4trYlErOGeRmpu3I4CmZlWzq04c8WR4k+k6E3TaQ0Af3Nrm3UsdXpzdadU315sl0zFTbbx2flSZSZgGvtFceOGFvhsq6fnmbm0WjY6j3vMUMOn4adM1Ldzyo/vxW7QeJgoW3377bTNv3ry42jcqA6n67mj7RmjQmC/dYGJRKUnt2rXte7Z3IakGLgoiNVOi51GlSpV8byNayZiuH9QNhzJJs6AatEQbKGsQrfI5zd5FKwFTUkyz7PifUtszuZNLntGHplrijB49OlC7O6qUQlPUXlqEo6nIMWPG2MeuFeq6LBYFBFrU1bhxYxNmJdXdOgObVatW2V22SpLvXU1SPWZaXHTuuefazMiVV17puxjJocGJskMKmLSrrF/3hjDRYDjWDqrKbmvAp1X/CgCOO+64vF9jkQzNDmgq32/Bl7LVan3mFxA5z0l1p1DAWdKsVNgGx87frkSJ33u7nkfauVmDQQWVThCtZMO1115rBzfKOGojGr12C+39raTPACVi3K31YpkxY0ZBBN4a5Drredxq1qxp4yNnpkDPSa0XU+ImFq1hCHvpYaIxJMF3HgTfyrhG2wbeTSuUY/UdVh9cv811wkiLT6OVoTRt2tRmfEpqracAUpm0fO4Ck6ibb7456elBBT9q0aVa8EL4kEpkcaVmC/RcUxuvQno+eWn2KdqGVB06dLAlA94gOt7Fq3qfDFt7RmUVlVTRa8rvONStW9e2qFQQqWBSOyxqMKjWtBrIxFqMGubAO57njvqoe8sjCvVYeddkKA5K1YgRI2xPbw0EC8Emgu/MH7hsUp1tqnWzmi5TGUrYPpxiSXbzA7V+y7det7k4ZqrHVc9Wlaeo3q+Qgu54AkqHfn7TTTeFsswrUSqBiFXmoEAnkeehyngqV65swqyk49GwYUO7kZHzbzy0oLpRo0YmzDQY0QxctDIldd6Jp4uMZmW827GHnTowXXTRRUn/vspQ0tEiOawxZGFFYnlKwY0+jNy7RCVKmZFCC7wTbZWksoqnnnrK/r9QA+9E+3GrfEmZXG3pXIiBt7M4Wq/PaJtXOX2nCbxN3K+tRAJv1Y6HPfB2WgFG4wTc8QbeU6ZMCX3g7bw/qSxCZRLq5lFShxctgNYiV82WqoTH+Zk21iq0wFtUlqpBbTLUdrbQAu9Eha+3VRroQ9QbqKouOFZtcKapti+ZqSC90RZqYKTFVxqBOovgSuK8ORfS9KIf9eOOVmPq5reIrpC1aNEi6s8K9fWXKcrwKhjVwjrvFtlhpWAw0RkB7/4R3g3cCoW6oCjLrRk6LQB2OJ/zKo9QsOne2VLPL83SBGkWPNs0qFXW32/NmV/Zl2Ya9Px02tAiOoJvH+pCENQXnJ7gfosh/GgEX4gLu7ycLcG10FSLZvwUYmajJOo5rR7Nfhvu6Hi2bt3aljIhMrhxBm7JBkiFQmUnmu5PZjZPMy1qNejM0pQrV84U2udTSbMs0UorYrWdDTu1PdWXklFa9OwsFCwp2VLIM6AOJfyUPFCb42jlrxq0aCBT0n4PiETwnWf0BNebhQKgWG/ABN7xZx81ukcktWvUCvX99tvP9OvXz+6cqn81MNVgJagD1CDQLJVmytTP2q9fc6Fz+kqrDj7RHtOvvPJK0f/DumtqSTTwbdKkiVm/fn3Mnt9aa6AZGZWYqHwRxu7g+dJLL9nuHYjN6UCkdoLOe1vz5s1N9+7d7QJ9tbs866yzOJQJottJHiy4jEbZNZVKLFy40H6vEb0ylnrs6ourOlP8j/oyaxpN7eHUeULBuBYJqsNCPm+pDORzWzP1jv/666/N/vvvbwd4Xko2qNuTWjWqP7NaqxY6bRSm93oF4t5Nw9wKvYQO6aOu1EuXLjV77bWX/V6vxR122IFDnGQMSeY7zyn7rexPz549IwJIAu/iVNOnKWr3DmXerakBZHcm7/HHHzeDBw+2WfBo09bqVqEPf2pJ/49TaqPWsup93q1bt6JAW5lIlQi4t0oHUqVklRN4C4F3ash853Hm201vuM52uQCQz20bVWur2SmV7CjDi9gzCIXYzQoIEjLfBYjAG0BY2jYiMQTeQH5hqAwAAABkCcE3AAAAkCUE38g5tTBS6yenlRHCg3Mbbpzf8OLchhfnNvcIvhGIN4KXX36Z4DuEOLfhxvkNL85teHFuc4/gGwAAAMgSgm8AAAAgSwi+AQAAAILv8Hnrrbfy8razcfuZlu/HJ99vP5Py/djk++1nUr4fm3y//UzL5+OTz489G/L9+LyV4dsn851FvBHkTr6/UPP99jMp349Nvt9+JuX7scn328+0fD4++fzYsyHfj89bBN8AAABAOJD5BgAAALKE4BsAAADIkjLZuqN8sH37dvvvpk2bMnL727Zty8vbzvTtO7ebr4+f24+Ocxvu506mz28+H5t8v31eu7k79pm+fc5tZo6/c30nlixJqe3xXKtArFmzxnTv3j3XDwMAAAB5aPjw4aZGjRolXofg2zPS+e2330yFChVMqVKlMn1+AAAAEALKZW/evNlUq1bNlC5dclU3wTcAAACQJSy4BAAAALKE4BsAAADIEoJvAAAAIEtoNYikqKXO6NGjzcKFC+3XunXrzDnnnGO6devme/1vv/3WjBkzxnz//ffmr7/+MtWrVzfHHXec6dq1a1LX1aKGF154wXz00Udm/fr1Zo899jCdOnUyrVu35ozm+fmdPXu26devn+/9DBkyxBxwwAGc44Cd2wceeMBMmTIl6n26zxuv3XCeW163+fu+vGDBAvPyyy+b+fPnmw0bNpiaNWuaY445xpxxxhmmfPnyRdfjtZs+BN9IigLeiRMnmr333tu0atXKTJo0Kep1p06dat/AjzrqKNO3b1/7Yl6xYoXtLJPsde+++277RnHhhReaOnXqmA8++MB+CKhjzbHHHstZzfPzKxdccIFp0qRJxGV169bl3Abw3OrD/JRTTin2+3fccYcpW7as2X///Ysu47Ub3nMrvG7z6/wuWbLE3HDDDfZztGfPnmbnnXe2Qfsrr7xig/L+/fsXXZfXbhqpzzeQqG3bttkv+eOPP7a3b99++4svvljsemvWrNneqVOn7Y899ljM24z3ujNmzLD3N3Xq1IjL+/fvv/2CCy7Y/vfffyf89yA45/ebb76x9/fRRx9xWvLk3JZ0HkeNGlV0Ga/d8J5bXrf5eX5Hjhxpb2f58uURlz/yyCP28vXr19vvee2mFzXfSIr6oMfTC10j8z///NOWhKTrup9++qntxa4Rvdvxxx9vR/Xz5s2L4y9AUM8v8u/c+nn33Xft/eh16eC1G95zi/w8v2XK/F8BRMWKFSMu32mnnWyvaufnvHbTi7ITZNScOXNM5cqVzc8//2zuvPNOs3jxYvv94YcfbncTdb/g472uLleN9w477BBxX5qKc35+4IEHcmbz9Pw6nnjiCXPvvfeacuXK2ZrSLl26mEaNGnFesyTR8+W2ceNG8/HHH5tmzZqZ3XbbrehyXrvhPbcOXrf5dX5VAz5u3DgzbNgwc9FFF9myE/3+O++8Y0499dSimm9eu+lF8I2M+vXXX82WLVvMoEGDzNlnn20uueQSW6v94osv2hfz4MGDi0by8V5XdW9+b/p6cxH9HPl7fvXBcNppp5nGjRvbDwLVKb7++ut2Eeatt95qDjroIE5vwM6t14cffmi2bt1qTjjhhIjLee2G99zyus3P87vrrrva9VKq59b1HB06dIj4ntduehF8I+PbreqNWotw9CYgWkSnqaynn37azJo1yzRv3jzh6yK853e//fazXw5lu7W46KqrrjLDhw8n+A7gufWb9nYybSiMc8vrNj/P76pVq+zi2V122cXcdNNNpkqVKrZ0U11VVLrSu3fvHP814UTNNzLKyUZ7s5UtW7a0/2o1daLX1fX8stvOZc7tID/Prx/VHx5yyCFm0aJFNqODzEv2fP3000/mxx9/NG3atLHdMLy3yWs3nOfWD6/b4J/f559/3rYQvP32282RRx5pZxzPPPNMm/VWbb9aSDq3yWs3fQi+kVFOHbbfyFzcU5vxXlfXUy3bP//8E3E9TacJ7ejy+/xGE+/1kB7Jni99YMuJJ57oe5u8dsN5bqPhdRvs86t+4XvuuWdEP29xWkiqFaFzm7x204fgGxl1xBFH2H+//PLLiMu/+OIL+2+DBg0Svq5KEDRS/+STTyKuN3nyZFOtWjVTv379jPwtyM759aONH2bMmGH23Xdfs+OOO3IqsiCZ86WNPNRfWK9Bv0Ewr93wnls/vG6Df3618Y4CbH2mumljHufnwms3vaj5RtL0QlYJgPOi1QtYq+Cd6S2NpDXtdeihh9qG/Rp160WvhR/6XmUE7u4V8V734IMPtvVqjz/+uN3xq3bt2nYR0MyZM821115brAsK8uv8avGPdlhT5kULLpcvX27eeOMN88cff5irr76a0xnAc+uYPn26nZrW5ld+eO2G99zyus3P86vF7XfddZcZMGCA6dixo33P/eGHH8xrr71mM+JOqQqv3fQqpWbfab5NFIgePXqY1atX+/7smWeesauoRW8U2rpWu1D+/vvvNjutXSi1La63bjDe6+qNZ9SoURHby2thCdvL5//51XbIOq9aCKTzrFrDhg0b2p61zGoE99yKPsCVMVMdabR2dbx2w3lued3m7/n95ptvbLCtNTVqJankh4J0faYqGHfw2k0fgm8AAAAgS6j5BgAAALKE4BsAAADIEoJvAAAAIEsIvgEAAIAsIfgGAAAAsoTgGwAAAMgSgm8AAAAgS9jhEigAHTp0SOj6tWrVMs8++6y5+eabzZw5cyI2bwgrbYWt3eO0jf1PP/1kN7IoXbq03eXtmGOOMaeeeqopUyb2W6a24e7Tp49ZunSp3czi9ddfL3ad9957zzz00ENRb+Poo482N9xwQ8RlDzzwgJkyZUrM+9d50/nz/m3acOPTTz+1G25UrVrVbhfdrVs3s9NOO/nezrZt28z48ePNu+++a1asWGF3zmvSpIn9nb322ivq/X/++ef2b9Yx1B5u++67rznzzDPtjnupPGf79etnDj/88BKPR6lSpewGMHvvvbc54YQTzHHHHWcvi+eY+9GGJPp7X3rpJXv8nO8dzuVuFSpUMJUqVbIbfx144IGmbdu2aX/tOPer59nxxx9vgurOO+80n332WdH3Oh/XXHNNTh8TEAQE30AB0Iee19y5c21Qtc8++9gvN/euZoVCW9i/+uqrNuBWwKhgce3atfY4zZs3z27hPHDgQBuElkQ7/f38889x3affsRdtB+2lXT6jWbZsmd0SWkG3dqdzW7dunbn++uvN8uXLzW677WaDbm1JrcBag4377ruv2PlW0Hzvvffav1mBpLaW1u188skndnBy9913+z7G//73v+bpp582O+ywg2nWrJkdfHz11VfmjjvuMJdccondyjoROtZHHHGE/b/373IowK1du7b9/z///GNWrlxpvv32W/ulc3fllVfan+k6fq8DJ4DX/XjPrd+5iXUeNfj6448/7HPm66+/NqNHj7YDCW3L7rdzZJg1bdrUPn90PGbOnJnrhwMEBsE3UAD8sk3KHCr4djKg0X5P2xRXr17dhJ0CL22n3K5du4i/V0Fr//79zXfffWeD8wsuuCDqbSjbreD7xBNPNBMnTox5nyUde6+TTjrJfvkZPHiwDb61fbST6XVo1kJ/g7LGN954ow2M5cknnzRvvvmmzZR7nx/KEivw3n333c2gQYNsplx0mb6///77zbBhw4puyxkAPPfcczbAVHB+wAEHFF2u4F8/UxCv24yXBgWxMqU61t7srwYVt99+uz0HJ598sqlXr55p1KiR/YoWfF988cVJZ6j9zqMGAh9++KEdjIwbN84GoNddd50pJM5ga/bs2QTfgAs13wCiUiZVZRfxlFvkOwXeCqy9Aw0Fi8paygcffBD195UtfvTRR20Zx0UXXWSyZdOmTbbUQxR8u6nERI9Z5+/yyy+PCJYVbFapUsVMnTrVXs87CyD6O5zAW4488khz2GGH2UHb9OnTi2W9FXCecsopRYG31KlTx3Tu3Nn+TNn2bFCQ78wUKAOeCzrWbdq0sQMjlaLoPLhLMAAUrvB/ogJIWrSab02jKzB/6qmnbKZX2cNff/3VXnbWWWcVZSJnzZplp91//PFHW86hUo6ePXv6lrVouv7tt98277//vs2WquZYtcXKXKp+15vRzSanpOC3336Lep133nnHZsf79u0btY46E1QKsnXrVrP//vvbgZLbl19+aY+jarXdQbQoQ63zoZpuXc85ZyrbUAZ/xx13NIccckix+1N5hoJIBfwKxh0qR3F+7nXUUUfZDLt+p1evXiYbdtllF/uvgv5c0jlRBlivAw0+NHiJlzLGqu/W60fnS5n7kmZeFi5caIN8ve5++eUXOzDTYPKggw4yXbp0iRhYqizm2muvtWU7KjHyo7py3f95551nf1/+/PNPO2OirL7WRej46ljvt99+dhZC9wWgZATfAJKmrJ7qWpXpVD2xAnVnUZuyfUOGDLGBa/Pmze2HvQLrVatW2dIFdzCtD/TbbrvNZikVmCsgULD+/fffm0ceecTMnz/fXHHFFTk7UwpIxRvAOhSUP//887bGVdnOeCmoUjmGgiTdtn5fgXIidEz9st6iRY+iwMiPLlfw7VzP/Tt169b1nfFwbmvRokURCzoV7EW7rxo1atjzqmBt48aNtg44kxQQKhAV74AkF7SAVsG3atA1yIyn9lszC/fcc48dPOn1oJp3vYZUuhJt8eprr71mS4N07vQ7eo3pOGhQqwHT0KFDiwLw+vXr23IcPabFixfb33HT/ar8SK9DZ2Cm4/rvf//b/o7OaePGje1zRANvDb7KlStH8A3EgeAbQFIUSCnAfvzxx+0HsXzzzTfmlltuMaNGjbJBhmp9neyoAkx9r+ywMnoKNB0KQBV4K3BVeYRuV7TgUYv1lFVWwOGXic0Gp1wiWtbyiSeesNnnf/3rXwndrgIWJ2Msr7zyig1o1OkkWqDvpqBHAx6VOLRu3brYz52AOFrNvnO5cz33/51z6uVc7vc7yvhHW5Cq39OiTV03U8H333//bQdKmo1RaYwWzgYhE6sBgAJuPUf0ulEpTkn0WtGgUwGwgm1123GC34cffjhq1xutCdDMUrVq1You020o8FcG+4UXXrAdUhyaVVKp1KRJk+yCWDctlNVj1evOeZ7otavAW68DdZ9RYO7QoErHHEBs1HwDSNqll14aEaQpoFbmU5lgBcrusgS1gHMWDCpgdGghmrKvKmu56qqrigJvUU2yk/FWAJ4Lyhoqu6+AsVOnTr4ZSrXw089iBVUOBUdaoKdZAgVGI0eONAMGDLDt6XRstFgwnnIJ1WsruGrRokVRmYXb5s2b7b/KSPpxAmXNPDic/8f6Hee24/kd98/c95UOOoYqg9LXGWecYQdvmg3Qwtm77roros49VxSkOqVImiWIRdlrDVQ0Y+QE3qK/RUGy+zXipg4z7sDbuW+1SFQA7a05123rdanjpcGymwJycS/y1WtVNDvjDrxFrw9l0gHERuYbQFI03awsrZfKTxYsWGADBy+nJZy7dlrBpjKWylD6TcerbEXBhkpPsk0ZetW1a/peGUNvBlkZSnUN0aJMLdiMl/5Wd0ZWAZAyjApq1N1D5SjTpk3zLSXxBt/i10LPLVq9vBaJxnNZLM7v5KIu391qULR4VMdPwaOeN+eff36xQDEXEjlGyjA7tfJeCuL12tKAz4+CdtXWq5RE2WhnEKd/169fb78qV65cNJBSAK4Bpm7PmT1RkK3bUCDfsmXLotvWTIKOpfq4a2ZGC1v13AWQGIJvAEnRh69fUONkOP1KHZysqTvLpqltUQCgr2g0ZR+LFgqq7tVLWelEa39V+6zMqQYGyvC7N3hxqLxmzZo1djORdPRwVrCoDK7KWDTtX1LwrZprfTmBe7TbKynbrDaS4i4VcX7H+ZmXc1vu7Gus+4l2X+ng12pQgyKtN9BzQY9N3VZySbMTTsY7nsW4zuA0Wm/zaJdrseVjjz0WMSvhpZ85wbeoO41ed2rL6ATfkydPts97LXR2zxxoZqd79+52fYOOr17/qhVXxl3nwFs3DsAfwTeApMTK4MWbBXUyc8qqaWfCVChj51cPq8AgkeBbtau33nqrzRyqPCTaDqHKDqoriGq19eWlAEYdY0QlNfH0uPabHShpoaW6i0Qr93CCNNWG+3Eudwdzzv81qPDjXO73OwowFYD7Bdh+v5cpGpCoTaL6fY8dOzbnwbcGhXou6DzF00s8mZkEDWIffPBB+3+VpigrrQGw89zQegstYPbObGhmSRsmaZZHz3s9/1QGpvtW8O11+umn23IylVupHEtrNXSM1WpSg1SV+wAoGcE3gJxyasZVcqHFYqnQbaTaS1oBqeqvVb6gFnGqly2JMvLuGnY3BTrOz+KtdVbAL9Hqep1Mqlq9SUndVZwWiSoD8uNc7t7J0fm/yhYUMHo7nji/4x4oKZuroFqLKfVz72Y2CrxVDqHrZLrTicMJclVmoYW7Wj+QK865Uu/xeGrQnbptZ1bIy73Y1aGBhs6XgmO/nUSdjj1+lP3WJk0KurV+QK0+9W+0gYLOo1Nn72wmpNp7tSRVGUs2W20C+Sj3hXAACpoWaWr6Wl0/ct2TWZlbZbzVDlHZ8liDAfWuVrDv9yUqRXG+V2Y/HlpsV1J7QFGWUgGt0+4tGtWV69gqO+kslnOo9EeZe/3cXdermn3NEmhQ4e7E4u4rLt7OM8q0un/u9tFHH/n+TibpHIoyuCUtBM1G1tt5PvgFxX6cDYKc54L3OaqMs9/l0WYWNAD0nn831ZYrYFa5iVP6FW031WibCanPvIJ/7aYKoGQE3wBySlPjbdu2tR/a6kOsLKWX2psps5dJTq9xZXwVjFx55ZUZW0CoKXpvXa4CF21qooBLpSzeOma/hZaqCS9pMaEyqKrj1W1rO3j34Gb48OH2WOvn3raGHTt2tP+OGDEiImhTYK2OGcqIakt1NwWWeiwK3lTe4NB5ffXVV+3PopXvpJtqvvX3iQYn6a4zj4eOtc7TTTfdZM+1FsU6A5RY9PxTXbbq/rXw1n2basvpV9PtdNpROZJ7lkUzOWoHWhINTvT4VOqk+9MsgV9bTbUSVeCvmRc3Zeg1yNDrJVpbSwD/Q9kJgJxTragylZq+VrZVWWIFjir9UB2qAggFd/EGL8nQ4klNvStIVDZP/ZT9qBtJqp5++mm7aE07eCpTqSy0NkNR8KPAWzsPRgtilJF2ssuxuqGIsvf6u/Q7asOndnBLliyxgwzV9/pl91Xrq10v1QFDv6MFdSobUQbVeXzechS1SdRiPM0GKOBURw5dRwGkHnOPHj3sddJNXU00E+DQYEGdcVRuoo19LrvssrTdV7TBmOqfnUy7zqUGNeq4okGAnk8qBbnwwgsTqllXi03tPKkvZc71PNHfpdvWeXcGYA4tutXzSfer15O6wOi469jo9aTvNYiNRj2/NSgUDYb9NljSImSVlig418yMjq8ej2ZWdF96jRJ8A7ERfAPIOWUm1dta097K3KmLhwJG9a5WGYQ+1P02kUknZ9peWT11jYgmHcF3165dbXb4559/toGwKGhRAKSsc0lBqjLPCuoUUMXTXUKBkmYUXnzxxaKe5Dqu7du3t4tJ3Z0vHAoYb7zxRhv0qQ7Y2b1Q2e5zzz036v0qyNSiUrWic9rlKdg/88wzE9pWPREKKN1BpQYHyswrgNT9xrNZUSxOp51oGXQFpc7OoLqO6tq1g6TKR/Q4atWqlfB9alGjXhOaDVFAreeJaun79+9fVMbjphIn7TirnvEaOOmc6Tml86zn28CBA0u8P5UaacCrAaA6yPhR2ZAGNcqA6zWqAZmeX/o7Tz31VN+OQACKK7U9maauAABkkEpUFLQqk55rgwYNsuVAGpD49d4OAw1gtLOqynS0rX06KfuuHTFV2pKOwSuQ78h8AwACSZnVBx54oCgYz8UOiqpZnzlzpp0N8HZxCRPV5Ysy5emiMhZ1vylpsSdQiAi+AQCBpIWDTt92lbxkM/jWpjMq01E9sxY4qqwiHSUsQct2q6xI9f/z5s2zxzedpSMqT/FuaQ+AshMAAIpRxl0LgLXmQOUSqh+Pp0d3Pnnvvfdsf271lFeP/F69eiVVnw4gMdR8AwAAAFlCn28AAAAgSwi+AQAAgCwh+AYAAACyhOAbAAAAyBKCbwAAACBLCL4BAACALCH4BgAAALKE4BsAAADIEoJvAAAAwGTH/wPCtjCVblgtIwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -85,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -101,14 +112,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Finding most likely periods: 100%|██████████| 1/1 [00:00<00:00, 29.80it/s]\n" + "Finding most likely periods: 100%|██████████| 1/1 [00:00<00:00, 65.34it/s]\n" ] } ], @@ -137,28 +148,28 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "Table length=1\n", - "\n", + "
Table length=1\n", + "
\n", "\n", "\n", - "\n", - "
Target_IDperiod_dayssecondary_period_daysgauss_widthmax_powersecondary_max_powerorbit_flagoflag1oflag2Flagsavg_period_days
int64float64float64float64float64float64float64float64float64int64float64
621246463.22967914764591773.21636224711885930.33188306480480350.948139023632630.19343617519244910.00.00.003.2296791476459177
" + "621246463.22606772954824453.23053124390477060.37180391343398830.95581961088991710.172427686461640670.00.00.003.2260677295482445\n", + "" ], "text/plain": [ "\n", "Target_ID period_days secondary_period_days ... Flags avg_period_days \n", " int64 float64 float64 ... int64 float64 \n", "--------- ------------------ --------------------- ... ----- ------------------\n", - " 62124646 3.2296791476459177 3.2163622471188593 ... 0 3.2296791476459177" + " 62124646 3.2260677295482445 3.2305312439047706 ... 0 3.2260677295482445" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -176,28 +187,18 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 8, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ @@ -227,69 +228,77 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ - "MODEL_DIR = '/Users/arcticfox/Documents/flares/run01/'\n", - "MODEL = [os.path.join(MODEL_DIR,i) for i in \n", - " os.listdir(MODEL_DIR) if i.endswith('.h5')][0]" + "models = stella.models.models\n", + "MODEL = models[0]" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 19, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "WARNING: No stella.DataSet object passed in.\n", - "Can only use stella.ConvNN.predict().\n" - ] - }, + "data": { + "text/plain": [ + "
\n", - "\n", + "
Table length=39\n", + "
Target_IDtpeakampdur_minrisefallprob
\n", + "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
Target_IDtpeakamped_srisefallprob
float64float64float64float64float64float64float64
62124646.01656.45766947437780.00517271866554260139.0307026803608960.00010.00688458976865427650.9807868599891663
62124646.01657.31324338198560.00935070228511011346.0427474926023450.00010.005440531357077170.9993744492530823
62124646.01659.18828153893080.0165110534040283139.068943053366020.00010.0048665709253705070.9999998807907104
62124646.01659.93274023421740.00531299853780956839.0434203414553450.00010.0099615092212989240.6145604252815247
62124646.01661.35915489099530.01616045832644144640.07148748342360.00010.0054786545406301720.9998658895492554
62124646.01664.60226137635350.0192907510039818140.1231279321261950.00010.0083774666962270731.0
62124646.01665.10504612819890.01314713709421687539.0896531890076840.00010.0080857918850959530.9999781847000122
62124646.01671.53841797829930.02035861226105141839.1231058612179940.00010.0077604368901831541.0
62124646.01673.18702736909740.0205590406398600839.114627785012330.00010.007054779840450441.0
62124646.01676.2536836973380.03055554684541682339.214232149922520.00010.0090138280819179881.0
62124646.01676.95506884504040.00673877124922315639.025499944224180.00010.0046305339257480510.997788667678833
62124646.01677.32451111334220.2810143935238597640.429627767115780.00010.0065647640076292621.0
62124646.01677.79534147014150.00859558528051674539.04217474905530.00010.00624890500430893250.9562909603118896
62124646.01679.16477600030750.006115484082584130539.035647558860110.00010.00713760243215867150.9747272729873657
62124646.01679.5717171545920.00905349498155829339.06350144752650.00010.0088848388797201030.9999923706054688
62124646.01681.73419719783940.01064266441690119239.0321765605989060.00010.0034022541541514470.9999966621398926
" + "62124646.01658.75352784437681.00521288015438872.11417844909402140.00010.0040226708672784470.9841311573982239\n", + "62124646.01659.18825863337251.01540605075848926.6215883690678130.00010.0042974098837592631.0\n", + "62124646.01659.92577275353071.00484290542816934.83036697330402550.00010.010.7176441550254822\n", + "62124646.01660.47161619324221.00594624385954120.95370765438614220.00010.00100073125708391550.5826319456100464\n", + "62124646.01661.35913198590261.0141612518202887.0053083661939090.00010.0050106850887689470.9999992847442627\n", + "62124646.01661.78969491418841.00368199462640862.78283486534602180.00010.010.6347841620445251\n", + "62124646.01662.88137942804971.00304089623071052.0609874920778570.00010.0063326416830458260.525276780128479\n", + "62124646.01664.6022384707951.017371302934228814.2301558599330620.00010.008676001460486881.0\n", + "62124646.01664.6022384707951.017371302934228814.2301558599330620.00010.008676001460486881.0\n", + ".....................\n", + "62124646.01676.85643538589851.00374065919382670.61064036016403190.00010.0010727136939040980.5605157017707825\n", + "62124646.01676.95365705910151.0061386042076984.1974325025577530.00010.0069212380141031340.9998787641525269\n", + "62124646.01677.32448820824951.262167964704223168.81587980867890.00010.0065127334925187291.0\n", + "62124646.01677.32448820824951.262167964704223168.81587980867890.00010.0065127334925187291.0\n", + "62124646.01677.32448820824951.262167964704223168.81587980867890.00010.0065127334925187291.0\n", + "62124646.01677.68281929706631.00319338476286670.63942896490743560.00010.00142287651193703070.721289873123169\n", + "62124646.01677.79531856504881.0080528819578535.3919451737033240.00010.0072619195274992790.9994544386863708\n", + "62124646.01679.16475309568051.00526545516737324.7225182400472620.00010.010.5875205397605896\n", + "62124646.01679.57169424949941.01116225857920538.1323096172897640.00010.008171252144681040.9998618364334106\n", + "62124646.01681.73417429321241.01122220838746873.91369382197692860.00010.0033597123524147320.9998935461044312\n", + "" ], "text/plain": [ - "\n", + "
\n", "Target_ID tpeak ... fall prob \n", " float64 float64 ... float64 float64 \n", "---------- ------------------ ... --------------------- ------------------\n", - "62124646.0 1656.4576694743778 ... 0.0068845897686542765 0.9807868599891663\n", - "62124646.0 1657.3132433819856 ... 0.00544053135707717 0.9993744492530823\n", - "62124646.0 1659.1882815389308 ... 0.004866570925370507 0.9999998807907104\n", - "62124646.0 1659.9327402342174 ... 0.009961509221298924 0.6145604252815247\n", - "62124646.0 1661.3591548909953 ... 0.005478654540630172 0.9998658895492554\n", - "62124646.0 1664.6022613763535 ... 0.008377466696227073 1.0\n", - "62124646.0 1665.1050461281989 ... 0.008085791885095953 0.9999781847000122\n", - "62124646.0 1671.5384179782993 ... 0.007760436890183154 1.0\n", - "62124646.0 1673.1870273690974 ... 0.00705477984045044 1.0\n", - "62124646.0 1676.253683697338 ... 0.009013828081917988 1.0\n", - "62124646.0 1676.9550688450404 ... 0.004630533925748051 0.997788667678833\n", - "62124646.0 1677.3245111133422 ... 0.006564764007629262 1.0\n", - "62124646.0 1677.7953414701415 ... 0.0062489050043089325 0.9562909603118896\n", - "62124646.0 1679.1647760003075 ... 0.0071376024321586715 0.9747272729873657\n", - "62124646.0 1679.571717154592 ... 0.008884838879720103 0.9999923706054688\n", - "62124646.0 1681.7341971978394 ... 0.003402254154151447 0.9999966621398926" + "62124646.0 1658.7535278443768 ... 0.004022670867278447 0.9841311573982239\n", + "62124646.0 1659.1882586333725 ... 0.004297409883759263 1.0\n", + "62124646.0 1659.9257727535307 ... 0.01 0.7176441550254822\n", + "62124646.0 1660.4716161932422 ... 0.0010007312570839155 0.5826319456100464\n", + "62124646.0 1661.3591319859026 ... 0.005010685088768947 0.9999992847442627\n", + "62124646.0 1661.7896949141884 ... 0.01 0.6347841620445251\n", + "62124646.0 1662.8813794280497 ... 0.006332641683045826 0.525276780128479\n", + "62124646.0 1664.602238470795 ... 0.00867600146048688 1.0\n", + "62124646.0 1664.602238470795 ... 0.00867600146048688 1.0\n", + " ... ... ... ... ...\n", + "62124646.0 1676.8564353858985 ... 0.001072713693904098 0.5605157017707825\n", + "62124646.0 1676.9536570591015 ... 0.006921238014103134 0.9998787641525269\n", + "62124646.0 1677.3244882082495 ... 0.006512733492518729 1.0\n", + "62124646.0 1677.3244882082495 ... 0.006512733492518729 1.0\n", + "62124646.0 1677.3244882082495 ... 0.006512733492518729 1.0\n", + "62124646.0 1677.6828192970663 ... 0.0014228765119370307 0.721289873123169\n", + "62124646.0 1677.7953185650488 ... 0.007261919527499279 0.9994544386863708\n", + "62124646.0 1679.1647530956805 ... 0.01 0.5875205397605896\n", + "62124646.0 1679.5716942494994 ... 0.00817125214468104 0.9998618364334106\n", + "62124646.0 1681.7341742932124 ... 0.003359712352414732 0.9998935461044312" ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -412,23 +429,41 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] }, + "metadata": {}, "output_type": "display_data" } ], "source": [ + "plt.clf()\n", "plt.figure(figsize=(14,4))\n", "plt.scatter(ff.time[0], ff.flux[0], c=cnn.predictions[0], s=5)\n", "\n", @@ -437,44 +472,44 @@ "\n", "plt.ylim(0.94,1.3)\n", "plt.xlabel('Time [BJD - 2457000]')\n", - "plt.ylabel('Normalized Flux');" + "plt.ylabel('Normalized Flux')\n", + "plt.show();" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(0.96, 1.05)" + "
" ] }, - "execution_count": 15, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ + "plt.clf()\n", "plt.figure(figsize=(14,4))\n", "plt.scatter(ff.time[0], ff.flux[0], c=cnn.predictions[0], s=5)\n", "for tpeak in ff.flare_table['tpeak']:\n", " plt.vlines(tpeak, 0,2, color='k', alpha=0.5, linewidth=5, zorder=0)\n", "plt.xlim(1660,1666)\n", - "plt.ylim(0.96,1.05)" + "plt.ylim(0.96,1.05)\n", + "plt.show();" ] }, { @@ -488,49 +523,55 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Text(1.1, 0, 'Time [BJD - 2457000]')" + "
" ] }, - "execution_count": 16, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ + "plt.clf()\n", "fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(14,4), sharex=True, sharey=True)\n", "ax1.scatter(ff.time[0], ff.flux[0], c=cnn.predictions[0], s=8)\n", "ax2.plot(ff.time[0], ff.flux[0], 'k.')\n", "for tpeak in ff.flare_table['tpeak']:\n", " plt.vlines(tpeak, 0,2, color='k', alpha=0.5, linewidth=5, zorder=0)\n", "plt.xlim(1662.5,1663.5)\n", - "plt.ylim(1.01,1.035)\n", + "plt.ylim(1.01,1.04)\n", "plt.xticks(np.arange(1662.5, 1664.0, 0.5))\n", "ax1.set_ylabel('Normalized Flux')\n", - "ax1.set_xlabel('Time [BJD - 2457000]', x=1.1)" + "ax1.set_xlabel('Time [BJD - 2457000]', x=1.1)\n", + "plt.show();" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "stella", "language": "python", "name": "python3" }, @@ -544,7 +585,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.12.12" } }, "nbformat": 4, diff --git a/docs/getting_started/other_features.ipynb.bak b/docs/getting_started/other_features.ipynb.bak new file mode 100644 index 0000000..b8bb38d --- /dev/null +++ b/docs/getting_started/other_features.ipynb.bak @@ -0,0 +1,550 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Other Fun Features" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some other features that are included in the $\\texttt{stella}$ package include finding rotation periods and fitting flares with a simple analytic model to extract parameters such as the equivalent duration. Here, we will go through each of these additional modules." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "sys.path.insert(1, '/Users/arcticfox/Documents/GitHub/stella/')\n", + "import stella\n", + "import numpy as np\n", + "from tqdm import tqdm_notebook\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.rcParams['font.size'] = 20" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First thing's first: we need a light curve! We're going to use the same one that has been used in the previous demonstrations." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "//anaconda3/lib/python3.7/site-packages/lightkurve/lightcurvefile.py:47: LightkurveWarning: `LightCurveFile.header` is deprecated, please use `LightCurveFile.get_header()` instead.\n", + " LightkurveWarning)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from lightkurve.search import search_lightcurvefile\n", + "lc = search_lightcurvefile(target='tic62124646', mission='TESS')\n", + "lc = lc.download().PDCSAP_FLUX.normalize()\n", + "lc.plot()\n", + "lc = lc.remove_nans()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1 Measuring Rotation Periods" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To measure the rotation period of a light curve, you need the following information: a target ID (can be anything you want), a time array, a flux array, and a flux error array. These can all be retrieved from the $\\texttt{lightkurve}$ object. Then, you initialize the class $\\texttt{stella.MeasureProt}$." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "mProt = stella.MeasureProt([lc.targetid], [lc.time], [lc.flux], [lc.flux_err])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The rotation measurement tool used in this class is a Lomb-Scargle Periodogram. You have the option the set the minimum frequency (minf=1/12.5) and maximum frequency (maxf=1/0.1) that the periodogram searches over. You can also set the samples per peak (spp=50). The default values are noted in parentheses." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Finding most likely periods: 100%|██████████| 1/1 [00:00<00:00, 29.80it/s]\n" + ] + } + ], + "source": [ + "mProt.run_LS()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calling this will create an $\\texttt{astropy.table.Table}$ attribute with some metrics about the rotation period measured in that light curve. The columns in this table include:\n", + "- Target_ID: the ID for that light curve.\n", + "- period_days: the period as measured in the first orbit.\n", + "- secondary_period_days: the period as measured in the second orbit.\n", + "- gauss_width: the width of a best-fit Gaussian to the most likely period.\n", + "- max_power: the power of the periodogram at the most likely period.\n", + "- orbit_flag: a combined flag per orbit (0 = reliable measurement).\n", + "- oflag1: period flag for the first orbit (0 = reliable measurement).\n", + "- oflag2: period flag for the first orbit (0 = reliable measurement).\n", + "- Flags: Defines a flag based on all observations of the given target. This mainly applies to stars observed in multiple sectors, otherwise it is the same value as the orbit_flag (0 = reliable measurement).\n", + "- avg_period_days: the average most likely period for that target. This is averaged over multiple sectors when available.\n", + " \n", + "Note that by fitting to each orbit, we are limiting the period search space to relatively short rotation periods." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Table length=1\n", + "
\n", + "\n", + "\n", + "\n", + "
Target_IDperiod_dayssecondary_period_daysgauss_widthmax_powersecondary_max_powerorbit_flagoflag1oflag2Flagsavg_period_days
int64float64float64float64float64float64float64float64float64int64float64
621246463.22967914764591773.21636224711885930.33188306480480350.948139023632630.19343617519244910.00.00.003.2296791476459177
" + ], + "text/plain": [ + "\n", + "Target_ID period_days secondary_period_days ... Flags avg_period_days \n", + " int64 float64 float64 ... int64 float64 \n", + "--------- ------------------ --------------------- ... ----- ------------------\n", + " 62124646 3.2296791476459177 3.2163622471188593 ... 0 3.2296791476459177" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mProt.LS_results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For this star, we find a period of 3.23 days. We can fold over this period in $\\texttt{lightkurve}$ to see if this period is found in the light curve:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAt8AAAFyCAYAAAAtYLZpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdd1xTV/8H8E8gIAIKBBRHHSgWW9djpdRZ9wAXrlpwb+1jRazWWYsDtYqb+vg8WrVW656gKCpq3ZSqOKoCKoIDUAQ0DBnJ7w9+uSUyDCEkIXzer5evV3Luufd+oVQ/nJx7jkgul8tBRERERESlzkjXBRARERERlRcM30REREREWsLwTURERESkJQzfRERERERawvBNRERERKQlDN9ERERERFrC8E1EREREpCUM30REREREWiLWdQH6ZODAgcjKyoJIJIK1tbWuyyEiIiKiMiA5ORlyuRwmJibYv39/kX0ZvvPIysqCTCYDACQmJuq4GiIiIiIqS7Kysj7Yh+E7D5FIBAAwMjKCjY2NjqshIiIiorIgKSkJMplMyJJFYfjOw9raGomJibCxscG2bdt0XQ4RERERlQEjR45EYmKiStOW+cAlEREREZGWMHwTEREREWkJwzcRERERkZZwzrca0tLShIn1RNqgeAjY3Nxc16UQERFRCTB8F4NMJsO+fftw9epVXZdC5VTLli0xaNAgGBnxQysiIqKyiOG7ANnZ2YiKilJqk0gkOHXqFK5evYrevXujXr16MDY21lGFVN7k5OTg0aNHCAgIAAAMHjxYxxURERGROhi+C5CSkgJvb2+ltoEDB+LmzZvo3bs3OnXqpKPKqDyrW7cuACAgIAC9e/fmFBQiIqIyiOG7AFZWVvDx8VFqy8zMxM2bN1GvXj3dFEUECD9/SUlJDN9ERERlEMN3AcRiMRwdHZXaYmNjAYBTTUinFD9/fNiXiIiobOJTW0REREREWsLwTURERFSKNm/ejAULFui6DNITnHZSzvTu3fuDfby8vNCkSROMHTsWs2bNQps2bYRjcrkcISEhCA4ORnR0NDIzM2Fvb4/PP/8c7u7usLW1LfLasbGx2L59O27fvo3s7GzUrFkTI0eORPPmzQEAN2/eRHBwMB48eIDk5GTY29ujS5cu6NOnD8Tif35cb9y4gdOnTyMiIgJxcXHo2bMnJk6cqHSvp0+fIjAwELdu3UJ8fDysra3RokULDBkyBFZWVgXWl56ejkmTJiExMRGrVq1CgwYNlI5LpVLs3LkTly9fxtu3b2Fraws3Nzf069evwOtt2rQJR48eLbA+ADhz5gyOHj2K2NhYmJmZoUGDBpgzZw4qVKhQ5PeRiIjKjufPn+PJkye6LoP0BMN3ObNixQql9zNmzECvXr3Qvn17oa169erIyMjId65cLoefnx8uXryIzp07Y8CAAahYsSJiY2MRFBSEuLg4zJ07t9B7P3nyBDNnzkTz5s3x3XffQSwW4+HDh3j37p3Q58SJE3j37h2GDBmCKlWq4P79+9i5cydiYmIwdepUod/169fx+PFjNG7cGG/fvi3wfjdv3sTdu3fRo0cPODg4ICEhATt37sTt27exbt06mJiY5Dtnz549yMnJKfB6GRkZmDNnDoyNjTF27FhYW1vj2bNnSEtLK7B/dHQ0Tp06VeiDkXv27MGBAwcwaNAgNGzYEG/evEF4eDjncxMRERkwhu9ypmHDhvnaqlSpkq+9oPB9/Phx/PHHH5gyZQq6du0qtDdp0gTdu3fHjRs3irz3hg0b0Lx5c8ycOVNoU4x4K0yaNElpVLpJkyaQy+XYsWMHRo0aJRwbNWoUxowZAwC4detWgff78ssv0bNnT4hEIqGtRo0a+P777xEaGqo0og/kjsofO3YMo0ePxoYNG/Jdb//+/UhPT8f69ethZmYm1FeYjRs3om/fvggJCcl37OnTp9i1axfmzZsHZ2dnof39moiIiMiwcM43qezw4cOoX7++UvBWMDY2VgqR74uNjcXff//9wWkvBU0HqVevHuRyOZKSkoQ2VXZ4rFy5slLwVlwLAF6/fp2v///+9z/06NEDH330UYHXCw4ORpcuXYTgXZRz584hPj4eAwYMKPD46dOnYW9vX+T3jIiIiAwPR75JJa9evUJcXBwGDRqk1vkPHjwAkDui7uXlhejoaEgkEvTu3Rv9+/cv8ty///4bJiYmsLe3V+ve718LAGrVqqXUfunSJURHR2P27Nl4+PBhvvPi4+ORlJSEypUrY9GiRbh+/TrMzMzQunVrjB07FhUrVhT6pqWlYevWrRg7dmyhQf3BgweoU6cO9uzZg4CAAKSmpqJBgwYYM2YMnJycSvx1EhERkX7iyDepJDExEUDuFBV1KEat/fz80Lp1ayxatAjt27fHtm3bEBQUVOh5z58/R0BAAFxdXZUCrjoyMzOxZcsW1KtXD82aNRPaMzIysHnzZgwfPrzQ+dmK+rdu3QpLS0v4+Phg+PDhuHTpEvz9/ZX67tq1C9WrV0e7du0KrSUpKQk3b95ESEgIJk2aJMyVnz9/PpKTk0v0dRIREZH+4sh3KVm6dCkSEhI0es2qVati9uzZGr1mcb0/jUNVcrkcANCpUycMHjwYANC0aVMkJiZi7969cHV1zXdOWloalixZAnt7ewwbNkz9ov/fzz//jPj4eKxYsULp69i7dy+sra3RpUuXD9Zfo0YNeHt7AwCaNWsGIyMj+Pv7Y9iwYahWrRqePHmCY8eOwc/Pr8ha5HI50tPT8dNPP8HBwQEA4OTkhDFjxiAwMBBDhw4t6ZdLREREeojhu5ToOiRrmmIJwZcvX6p1vqWlJYDcwJ1Xs2bNcO7cOaSlpSmNOmdlZcHX1xdSqRQrVqxQaZ51UX777TecP38e8+fPR506dYT2hIQEHDp0CHPnzkVqaiqA3OUGgdwR8fT0dFSsWFGo//0HLBUj6DExMahWrRq2bNmCNm3aoGrVqpBKpQByd6PMzs6GVCqFubk5jIyMYGlpiUqVKgnBGwAqVaqEevXqISYmpkRfKxEREekvhm9SiZ2dHapXr47r16+rNQpdu3btIo9nZWUJr2UyGVauXImHDx9i2bJlak91UQgICMC+ffswdepUfPbZZ0rH4uPjkZ2dXeDmB3PmzIGTkxP8/PxQrVq1ApcmVMjMzASQu4pJQkICzp07p3T85MmTOHnyJDZs2IBatWqhdu3aePHiRYHXyvu9ICIiIsPC8E0q69u3LzZu3IgzZ86gc+fOSsdkMhlu3LiBFi1aFHhuw4YNUalSJYSHh8PFxUVov3HjBqpUqaK0ysnGjRsRGhqKBQsWoG7duiWq+fz589i0aROGDx+OTp065Tvu4OCAJUuWKLU9evQImzdvxjfffCNssmNiYoLmzZvnW9bw5s2bAID69esDyF03/f3wvHz5cjRs2BB9+vQRfpH4/PPPcfr0aTx69EhYgeXNmzd49OgR+vTpU6KvmYiIiPQXwzepzM3NDX///TfWrVuHe/fu4YsvvoCZmRmePn2KEydOoGrVqoWGb7FYDE9PT2zevBmWlpb45JNP8Ndff+HChQv497//LfTbu3cvgoKC0L9/f5iYmOD+/fvCsdq1awtTUxISEhAZGQkAePfuHV68eIFLly4B+Get7Nu3b2PNmjVo2rQpGjdurHQtOzs72NnZwdLSstC1uh0dHeHo6Ci89/DwwIwZM+Dn54dOnTrhxYsX+PXXX9GhQwdUr14dQMHrqJuamsLW1lbpPi1btkSDBg2wbNkyDBs2DKampti3bx/EYjF69uxZxH8FIiIiKssYvkllIpEI06dPR/PmzREcHIw//vgDWVlZsLe3h4uLS6FbrCv06tULcrkcR48exd69e2Fvb4/JkyejW7duQh/FRj0HDx7EwYMHlc5fsmSJEGBv3bqFtWvXCseuX7+O69evA8idZgJA2MI+PDwc4eHhStfy8PCAp6dnsb5+R0dH+Pj4YNu2bVi8eDEsLS3RvXt3DB8+vFjXAXLXKf/xxx+xefNm/Pzzz8jKykKjRo2wbNky2NjYFPt6REREVDaI5IplHAgjR45EYmIibG1tsW3bNqVjsbGxWLVqFaZNm5ZvjWgibeHPIRFR2bNw4UJER0djy5Ytui6FSklRGfJ9HPkuQHZ2NqKiopTaCtpunYiIiIioOBi+C5CSkiKs5azAebhEREREVFIM3wWwsrKCj4+PUltGRoawRToRERERkToYvgsgFouVVrkAcufaEhERERGVhJGuCygrjIxyv1U5OTk6roTKM8XPn+LnkYiIiMoW/guuIsXyb48ePdJxJVSeKX7+uBwhEVHZwYXlKC9OO1GRubk5WrZsKawhXa9ePRgbG+u4KiovcnJy8OjRIwQEBKBly5bCZkNERFQ2iEQiXZdAeoLhuxgGDRoE4J9NXIi0rWXLlsLPIRERlQ2KDd+IAIbvYjEyMsLgwYPRu3dvJCUlQSaT6bokKieMjIxgY2PDEW8iojIoJSVF1yWQHmH4VoO5uTlDEBEREREVGx+4JCIiIiLSEoZvIiIiIiItYfgmIiIiItIShm8iIiIiIi1h+CYiIiIi0hKGbyIiIiIiLWH4JiIiIiLSEoZvIiIiIiItYfgmIiIiItIS7nBZgOzsbERFRSm1SSQSSCQSHVVERERERIaA4bsAKSkp8Pb2Vmrz8PCAp6enjioiIiIiIkPA8F0AKysr+Pj4KLVx1JuIiIiISorhuwBisRiOjo66LoOIiIiIDAwfuCQiIiIi0hKGbyIiIqJSJJfLdV0C6RGGbyIiIqJSxPBNeTF8ExEREZUikUik6xJIjzB8ExERERFpCcM3EREREZGWMHwTEREREWkJwzcRERERkZYwfBMRERERaQnDNxERERGRlujt9vLp6ek4ePAgIiIiEBERAalUCi8vL3Tp0uWD50ZERCAkJAS3bt1CQkICKlWqBCcnJwwbNgw1a9bUQvVERERERPnp7cj3mzdvsHv3bsTGxsLBwaFY5x44cACXL19Gs2bNMG7cOPTo0QN3797F1KlT8eTJk1KqmIiIiIioaHo78i2RSLB9+3bY2NggMjIS06ZNU/lcd3d3TJ8+HSYmJkJbu3btMHnyZOzfvx/fffddaZRMRERERFQkvQ3fJiYmsLGxUevcTz75JF9bjRo1ULt2bcTGxn7wfJlMhpSUlA/2s7KyUqs+IiIiIiqf9DZ8a5pcLkdycjJq1679wb5JSUkYOnToB/sFBARoojQiIiIiKif0ds63pp07dw6JiYlo166drkshIiIionKqXITv2NhYbNy4EQ0bNkSnTp10XQ4RERERlVMGH76TkpKwcOFCmJubY9asWTA2NtZ1SURERFSOyOVyXZdAekStOd8XLlxQafpGVlYWtm3bhnHjxqlzmxJLTU2Fj48PUlNTsWzZMtja2qp0no2NDdavX1/K1RERERFReaNW+F6xYgXCwsIwYcIEmJubF9jnyZMn8PPzQ0xMjE7Cd2ZmJhYtWoRnz55h8eLFKj1oqWBkZMSVTIiIiIhI49SadlKnTh2cPXsWXl5euHfvXr7jhw8fxrRp0/DkyZNSf8AxIyMDsbGxSksD5uTkYPny5bh//z5mzZqFhg0blmoNRERERESqUGvke9WqVdi2bRsCAwMxe/ZsDBw4EB4eHkhJScHq1atx69YtmJubY8qUKWjfvr3axQUGBiI1NRWJiYkAgNDQUOF1r169YGFhgcjISMyZMwceHh7w9PQEAGzZsgXXrl2Di4sL3r59i7Nnzypdt2PHjmrXRERERESkLrXCt4mJCcaNG4cWLVpg7dq12LdvH/7880+8fPkSUqkUTZo0wdSpU1GlSpUSFXfo0CEkJCQI769cuYIrV64AADp06AALC4sCz3v06BGA3LAeGhqa7zjDNxERERHpQok22fnss8+wfPlyeHl5ITo6GgDQvn17jW3f/ssvv3ywT5MmTfJtdrN06VKN3J+IiIiISJNKtNRgREQE5s+fj7S0NEgkEgC5K6H89ttvyMnJ0UiBRERERESGQq3wLZfLsXv3bsycORMvXryAm5sb/vvf/+LHH3+ElZUV9u/fjxkzZuD58+earpeIiIiIqMxSK3zPnDkTu3btgqWlJebPn4+JEyfC1NQUn332Gfz9/fHFF18gKioKXl5eCAoK0nTNRERERERlklrh+/79+2jRogX8/f3h7OysdKxSpUqYM2cOvv32W4hEImzcuFEjhRIRERERlXVqPXA5adIkuLq6Ftmna9euaNKkCVatWqVWYUREREREhkatke8PBW+FatWqYdmyZercgoiIiIjI4JRotROVbmBU6rcgIiIiIioT1Jp2EhISUqz+nTp1Uuc2REREREQGRa3wvWbNGohEog/2k8vlEIlEDN9ERERERFAzfH/99dcFhm+ZTIZXr17hzp07iI+PR+fOnVG1atUSF6lt2dnZiIqKUmqTSCTCRkJEREREROpQK3x7enoWeTwnJwebN2/GxYsXsXLlSrUK06WUlBR4e3srtXl4eHzw6yYiIiJ6n1wu13UJpEfUCt8fYmxsjLFjxyI0NBS//vorZsyYURq3KTVWVlbw8fFRauOoNxERERGVVKmEbyA3gNevXx83b94srVuUGrFYDEdHR12XQUREREQGplTXAUxOTkZGRkZp3oKIiIiIqMwolfAtk8kQEBCA+/fvw8HBoTRuQURERERU5qg17WTu3LmFHktPT0d8fDykUilEIhG+/vprtYsjIiIiKuv4wCXlpVb4vn37dpHHjY2N8cknn8DDwwPNmjVTqzAiIiIiIkOjVvjevHlz4RcUi1G5cmWIxaX2LCcRERFRmaHKxoRUfqiVkMvixjlERERERLpWqqudEBERERHRP1Qa+U5ISCjRTThSTkRERESkYvgeO3ZsieYrHTlyRO1ziYiIiIgMhUrhu1GjRnxYgIiIiIiohFQK30uXLi3tOoiIiIiIDB4fuCQiIiIi0hKGbyIiIiIiLVEpfPft2xfr1q0r8FhISAju3bun0aKIiIiIDAW3l6e8VArfcrm80B+cNWvWIDg4WKNFEREREREZIu4BX4Ds7GxERUUptUkkEkgkEh1VRERERESGgOG7ACkpKfD29lZq8/DwgKenp44qIiIiIiJDwPBdACsrK/j4+Ci1cdSbiIiIiEqK4bsAYrEYjo6Oui6DiIiIiAyMyuE7KSkJd+7cKfYxAGjcuHHxKyMiIiIiMjAqh+8bN27gxo0bxT4GAEeOHCl+ZUREREQGQCQS6boE0iMqhe9GjRrxB4eIiIiIqIRUCt9Lly4t7TqIiIiIDBI32aG8uL08ERERkRY8ffpU1yWQHmD4JiIiItKCyMhIXZdAeoDhm4iIiIhISxi+iYiIiIi0hOGbiIiIiEhLGL6JiIiIiLSE4ZuIiIiISEsYvomIiIiItIThm4iIiIhIS1Ta4XLu3Lkluomvr2+JziciIiIiMgQqhe/bt28X2C4SiQrdMlVxTCQSqV8dEREREZEBUSl8b968OV/boUOHEBQUhLZt2+LLL79E1apVAQAvX77E+fPncfnyZfTo0QP9+vXTbMVakJ2djaioKKU2iUQCiUSio4qIiIiorOOAJAEqhm9FsFY4d+4cjh8/jnnz5uHzzz9XOubg4AAXFxeEhYVh0aJF+Pjjj/Odr+9SUlLg7e2t1Obh4QFPT08dVUREREREhkCl8P2+I0eO4NNPP80XvPNydnbGp59+iiNHjqBjx45qF6gLVlZW8PHxUWrjqDcRERERlZRa4Ts2NhYtW7b8YD+JRIJr166pcwudEovFcHR01HUZRERERGRg1Fpq0MzMDBEREZDJZIX2kclkiIyMhJmZmdrFEREREREZErXCd/PmzREfH48NGzYgLS0t3/H09HRs2LAB8fHxaN68eYmLJCIiIiIyBGpNOxkxYgTCw8Nx6tQpXLx4ES1atECVKlUA5K528tdffyE9PR3W1tYYPny4RgsmIiIiIiqr1ArfdnZ2WLFiBTZs2IAbN27gwoUL+fo0b94ckyZNEkI5ERERUXlU2J4oVD6pFb4BwN7eHgsWLEBcXBz+/vtvvH79GkDuQ5affvopqlWrprEiiYiIiIgMgdrhW6FatWoM2kRERESF4OY6lFeJwzcAPH/+HG/evEGlSpVQs2ZNTVySiIiIiMjgqB2+s7KysGvXLpw4cQKpqakAgE6dOsHLywsAcPbsWRw+fBheXl6oV6+eZqolIiIiIirD1Fpq8N27d5g9ezYOHDgAExMTtGjRIt/DBE2bNkV0dDQuXryokUKJiIiIyiI+cEl5qRW+Dx48iIiICHTp0gWbNm3C/Pnz8/WxtbVFrVq1cPPmzRIXSURERERkCNQK3xcuXECVKlXwzTffwNTUtNB+NWvWxKtXr9QujoiIiIjIkKgVvuPj4+Ho6AhjY+Mi+4nFYkilUrUKIyIiIiIyNGqFb1NTU5VCdXx8PCwtLdW5BRERERGRwVErfNerVw9RUVFISUkptE9cXBwePXqEBg0aqF0cEREREZEhUSt8d+vWDenp6VixYkWBAVwqlWLdunXIyclB9+7dS1wkERERUVn37NkzXZdAekCtdb7bt2+P0NBQXLhwAePGjcMnn3wCALh37x4WL16MO3fuIC0tDR07doSLi4tGC9aG7OxsREVFKbVJJBJIJBIdVURERERl3erVqzFkyBBdl0E6pvYmO9OnT0f9+vVx8OBB3LhxA0DuTpfPnz+Hubk5hg0bhoEDB2qsUG1KSUmBt7e3UpuHhwc8PT11VBERERERGQK1w7dIJEL//v3Rt29fPHz4EAkJCZDL5bC1tUWDBg1gYmKiyTq1ysrKCj4+PkptHPUmIiIidYhEIl2XQHpE7fCtYGxsjI8//hgff/yxJurRC2KxGI6Ojroug4iIiIgMjFoPXK5duxb+/v54/vx5kf2Cg4Oxdu1atQojIiIiIjI0aoXvM2fO4NSpU5g+fTrCw8ML7ff3338jJCRE7eKIiIiIiAyJWuEbAOzt7fHu3Tv4+PggMDBQkzURERERERkktcN3o0aNsGTJElSqVAmbNm2Cv78/cnJyNFkbERERUZknl8t1XQLpEbXDNwA4OTlh1apVcHBwwKlTpzBv3jy8efNGU7URERERERmUEoVvALCzs8Py5cvRunVr3L17F9999x2ePHmiidqIiIiIyjyOfFNeJQ7fAGBqaoqZM2fC09MTCQkJ+P7773HlyhVNXJqIiIiIyGCUeJ3vvL7++mvUqVMHq1evxrJly2Btba3JyxMRERERlWkaGfnOq1WrVvjpp59gZ2eHpKQkTV+eiIiIiKjMUmvk29fXFzY2NoUed3BwwKpVq3DixAnIZDK1iyMiIiIiMiRqhe8mTZp8sI+VlRUGDx6szuUBAOnp6Th48CAiIiIQEREBqVQKLy8vdOnSpVTPJSIiIiIqLRqfdqIpb968we7duxEbGwsHBwetnUtEREREVFpUGvleu3YtRCIRhg0bBhsbG6xdu1blG4hEIkyZMqXYhUkkEmzfvh02NjaIjIzEtGnTtHIuEREREVFpUSl8nzlzBiKRCAMGDICNjQ3OnDmj8g3UDd8mJiZFzisvrXMBQCaTISUl5YP9rKys1L4HEREREZU/KoVvX19fAECVKlWU3huqpKQkDB069IP9AgICtFANERERERkKlcL3+w9YqvLAJRERERERKdPbBy6JiIiIiAwNwzcRERERkZaoNO1k7ty5JbpJWZsjbmNjg/Xr1+u6DCIiIiIyMCqF79u3b6t9A5FIpPa5umJkZMSVTIiIiIhI41QK35s3by7tOtSWkZGBly9fonLlygzMRERERKTXVArfVatWLe06ChQYGIjU1FQkJiYCAEJDQ4XXvXr1goWFBSIjIzFnzhx4eHjA09OzWOcSEREREWmTSuFbVw4dOoSEhATh/ZUrV3DlyhUAQIcOHYoM0CU5l4iIiEhT5HK5rksgPaLX4fuXX375YJ8mTZoUuNmNKucSERERlTaGb8pL7fCdkZGBI0eO4OrVq3jx4gXS09ML7XvkyBF1b0NEREREZDDUCt+pqamYNWsWYmJiYGRkBLFYDLlcDhsbGyQnJwu/4Sm2oyciIiIqr8riym9UetTaZGf//v148uQJunfvjj179qB169YQiUT49ddfsW/fPkydOhU2NjZwcnLS65VSiIiIiIi0Sa3wffXqVUgkEowfPx6mpqZKv9GZmpqiU6dOWLRoEa5cuYJDhw5prFgiIiIiorJMrfCdkJCA+vXrQyzOnbViZJR7mezsbKFP7dq10bhxY5w5c0YDZRIRERERlX1qhW9TU1OYmJgI7ytWrAgASEpKUupXqVIlxMfHl6A8IiIiIiLDoVb4trOzw6tXr4T3H330EQDgzp07QltOTg4iIyNRqVKlEpZIRERERGQY1ArfjRo1QnR0NNLS0gAALi4uMDIywv/+9z8EBQUhNDQUS5cuRUJCAho3bqzRgomIiIiIyiq1lhps164doqKicP/+fXz22WewtbXFiBEjsGXLFmzcuBEAhKUHR44cqcl6iYiIiIjKLLXCd6NGjeDn56fU5u7ujk8++QRXrlyBVCpFzZo10aVLF047ISIiIiL6fxrdXt7JyQlOTk6avKROZGdnIyoqSqlNIpFAIpHoqCIiIiIqq7jJDuWl0fBtKFJSUuDt7a3U5uHhAU9PTx1VRERERESGoEThOyMjA1FRUUhKSkJWVlah/Tp16lSS22idlZUVfHx8lNo46k1EREREJaVW+JbL5di5cyeOHj2Kd+/eFdlPJBKVufAtFovh6Oio6zKIiIiIyMCoFb53796NvXv3QiwW44svvkC1atWEjXaIiIiI6B9yuVzXJZAeUSt8BwcHw9zcHCtWrECtWrU0XRMRERERkUFSa5OdN2/eoHHjxgzeRERERETFoFb4rlGjBmQymaZrISIiIjI4nHZCeakVvt3c3HD79m3Ex8druh4iIiIiIoOlVvh2dXVF165dMWvWLJw+fRqJiYmarouIiIiIyOCovc53jx49EB4ejvXr13+w75EjR9S9DRERERGRwVArfN+/fx/z589HRkYGRCIRLC0tYWZmpunaiIiIiIgMilrhe+vWrcjIyICHh+2fJKQAACAASURBVAf69u0Lc3NzTddFRERERGRw1Arfjx49gpOTEzw8PDRdDxERERGRwVLrgcuKFSuiatWqmq6FiIiIiMigqRW+nZ2d8eDBA+Tk5Gi6HiIiIiIig6VW+B4xYgSMjIywbt06pKamaromIiIiIoNx/fp1XZdAekStOd/btm1DnTp1cO7cOVy7dg0NGjSARCKBkVH+LC8SiTBlypQSF0pEREREVNapFb7PnDkjvE5LS0N4eHihfRm+iYiIiIhyqRW+fX19NV2HXsnOzkZUVJRSm0QigUQi0VFFRERERGQI1ArfTZo00XQdeiUlJQXe3t5KbR4eHvD09NRRRURERERkCNQK315eXqhevTpmzZql6Xr0gpWVFXx8fJTaOOpNRERERCWlVvh+9uwZPvroI03XojfEYjEcHR11XQYRUZnz4sUL2NnZwcTERNelEOmlqKgoZoxyTq2lBmvUqIG3b99quhYiIirjevfujfPnz+u6DCK9df/+fV2XQDqmVvju2rUr7ty5g9jYWE3XQ0RERERksNQK371790bnzp0xZ84cHD58GM+fP0dWVpamayMiIiIiMihqzfnu27cvAEAul2Pr1q3YunVrkf2PHDmizm2IiIiIiAyKWuHbzs5O03UQERERERk8tcL3L7/8ouk6iIjIQOzYsQNdunTRdRlERHpJrTnfREREhblz546uSyAi0lsaC99SqRRSqVRTlyMiIiIyONnZ2bougXRMrWknCmFhYTh69Cju3buHzMxMAICpqSk+/fRT9O7dG87OzhopkoiIiMgQLF68GO7u7roug3RI7fC9adMmBAYGQi6XAwDMzc0hEomQmpqKGzdu4ObNm+jduzfGjh2rsWKJiIiIiMoytcL3hQsXEBAQACsrKwwePBgdO3aEhYUFACAtLQ1nz57Fnj17EBAQACcnJ7Rr106jRRMRERERlUVqzfk+duwYTExMsGzZMvTq1UsI3kDuCHjPnj2xdOlSiMViHD9+XGPFEhERERGVZWqF7+joaDRt2hQ1a9YstE/NmjXRtGlTPH78WO3iiIiIiIgMiVrhOysrC2ZmZh/sZ2Zmxm3niajc279/P2JiYnRdhlYpHsInIiJlaoXv6tWr486dO8jIyCi0T0ZGBu7cuYPq1aurXZyuZGdnIyoqSunP69evdV0WEZVRy5Ytw40bN3RdhladOHFC1yUQEekltcJ327ZtkZKSAl9fXzx//jzf8RcvXmDp0qV48+ZNmXzYMiUlBd7e3kp/+A8JEalDseHMokWLdFyJdnHAgoioYGqtdtKvXz9cu3YN4eHh+Oabb1C/fn1UrVoVAPDy5UtERUVBJpPB0dGxTK5laWVlBR8fH6U2iUSim2KISGW7d++Gvb09OnbsmO+YVCqFpaWl8P7Vq1eYMmUKfv/9dwC5Ifn333+Hp6cnGjduXOx7Z2ZmYurUqdiwYYNS+7Fjx4TXzs7OCAsLg0wmQ2ZmpjB97/Tp08jKyoKrq2ux76uv/P39MXLkSF2XQUSkd9Qa+a5QoQKWLFmCnj17QiwWIzIyEpcuXcKlS5cQEREBsViMnj17wtfXFxUqVNB0zaVOLBbD0dFR6Q/DN5F+kEqlePbsmVLbu3fvkJSUBD8/P8yYMSPfOampqejQoQMAwM3NDXfu3EFKSgoiIiKEPkFBQQgODoa/vz+A3GVTi5paBwBv376Fv78/kpOTER4ejtDQ0Hx90tPT87WdOXMGbdu2Fd6fPHkSQUFBRd6Linbu3DmcO3dO12UQEX2Q2pvsVKxYERMmTMCIESPw8OFD4SNGiUSC+vXrq/RAJhFRce3btw87duzAmTNnhLbFixcjJCREeH/y5El07NgRMpkM3bp1Q6VKlQAAcrkcCQkJGDlyJBwcHAAAt27dwujRo4Vzw8LCcPbs2Xwhvk+fPmjWrBk6d+6MIUOGIDMzEy9fvgQA3L59G3/99RcA4K+//sKECRMwePBgGBkZITAwUOk6MTExSEpKAgDExcWhWrVqkMvluHz5MqZOnYo1a9bg8uXLaN26taa+ZeXCkSNHYGxsLPySRUSkr0q0vTyQu6JJo0aNNFELEVGBvvnmG2RnZ8PHxwcikQgpKSm4desWmjZtinHjxsHc3Bzv3r0T+s+dO1fp/LS0NACAi4uL0KZYBjVv8FYoaPT86NGjOHr0aIFztxXBGwAmTJgAANizZ0+BX0v//v2F1xs2bMC8efOElVCuXLkCAJgyZQr+85//4MCBA5gzZw4qV64snHPw4EE0a9YM9evXL/D65dWzZ89Qq1YtXZdBRPRBak07ISIqLRkZGYiPj4eLiwsSEhKwbds2hIaG4vr168LDi0BuaF65ciVu3LiBxMREla4tl8tLq2y1HD9+HK1bt8ajR48AADk5OfD09AQATJo0CadPn8aNGzeEB9vPnTuHJUuWIDQ0tMBlXFeuXKm94lXwoWk7mvTo0SOcP39ea/cjIlKXSiPfu3btKtFNPDw8SnQ+EZVdd+7cwYMHDzBgwACl9uzsbGRkZGDLli349ttvIRKJ4OHhgcjISKGPm5ub0jlz5sxBtWrVhPeKv5vu379fil+BduWdhw4A3333Xb4+IpEIrVq1QnBwMGQyGWbNmoXNmzdj165d6Ny5Mxo2bKiTqX9bt25Vev/f//4XXl5eWq+DiEifqRy+RSJRsUaNRCKR8Jrhm6j8Uqx40adPHyxevBjHjh2Dvb094uPjMW7cOGzfvh1XrlzBhg0blIJ3YeLi4kq5Yv3n5+cHAOjWrZvQphgJHzt2LKZOnQpnZ2fUq1cPpqamAHJ/2RGLSzzTsEg///yz0vvffvuN4ZuI6D0q/U08fPjwYl00MTERp06dQmZmplIIJyLDl5aWhvv37+Ozzz5TmibSqlUr4XV8fDwAYNOmTQCAyMhIdO3aVbuFGpi83981a9YIr3ft2oWIiAj8+OOPAABPT09MmzYN3t7esLOzw8yZM4VQ7ubmhgMHDqBixYraLT6PtLQ0xMTEoGHDhjqrgYioNKkUvgcOHKjSxZKSkrBv3z4EBwcjKysL5ubm6NOnT4kKJCLdOXLkCDZt2oTffvsNNjY2AHJX9qhRowZsbW2V+r5+/RoSiQRhYWGYNm0aXFxcClx6j7Tr/U8ef//9d1hbW+PChQsAgOnTpwvhOyEhAVlZWViyZInONgX6448/MG/ePISFhal8zoMHD0qxIiIizdLIZ5ApKSnYv38/goKCkJWVBTMzM/Tr1w/u7u5Km1oQUdly6tQpxMXF4cmTJ+jatSvc3d1x+PBhAMCFCxdgZmYGPz8/HD58GO/evcPChQsxf/58AGDw1mN5NwJq06YNAAifPOzatQtBQUFC+M7OzoaxsbHan2K6urpi+PDhxZ5+mJGRofK89bdv3wqvs7KyYGJiUqx7ERFpU4nC95s3b3DgwAEEBQUJf1EOGDAA/fr1E9bVJaLCvXr1CnZ2drouA2/fvkWlSpWQmZmJt2/fwtbWFpmZmbh69SqA3F+wAQjBGwDatWuHunXrIjo6WmhTBG8qe06dOgXgn6lAS5YsgZGREfbv3481a9YImwJdvnwZYrEYxsbGqF+/PqytrSGVSgsNyi9fvsSLFy+KXc/Vq1dVXrM77/NId+/exb/+9a9i34+ISFvUCt9SqRQHDx5EYGCgELr79++P/v37K61HS0RF69GjR7E+XteE9wN/cnIyunTpgq+++gp16tTBunXrsGvXLqX1qBXzhd+XN3iTYTl48KDweurUqQgMDMSAAQOU1lP38PDArl27UKdOHfTr16/Qa6kzaj59+nSV/9/IG77v37/P8E1Eeq1Y63ynpqZix44dGDt2LPbv3w+5XA53d3ds2rQJI0eOZPAm0kNSqVQITD179kSPHj2QmpoqHE9OTgYA7N27F2/fvsW7d++UgrfiGlS+9erVSyl4A/8s9fjkyZMil3vcuXMnkpOTkZqaiszMTJXvmffntCh5w/f69etVvj6RrhS0Tj+VHyqNfKelpeHw4cM4evQo0tLSYGpqir59+2LAgAGwtrYu7RqJSE1Xr17F5MmTAeTO6VWsMpKSkoKjR4/m25Rl48aNWq+RDMOJEyeKPN6lSxcAQKNGjTBu3DhhGktRIiMjVRrFvn37tvD6/V8QiPTRkSNHVF7MggyPSiPfo0ePxp49e5CdnY3evXtj06ZNGDNmDIM3kQaoGhbCwsKUpgJ8yKtXr4TgDfwzpxfIXXNb33ZD1FcVKlTQ6PXyhsnffvtNo9cuC+7evYupU6ciOzv7g33Hjh2r0jXf/6VR8WkOkb5S5eefDJdK4TstLQ1A7sckx48fx+jRo9GvXz+V/xBR4fbv369SvwsXLmDnzp0FHpsyZYpSPyB3PjmVXEBAAADAxcWlwOO///47AgMDAQDGxsaoXbs26tSpg5o1awp9Ro0aBQDw8fHB5s2bcfDgQVy6dAmffPKJ0prcitHh8qBly5Z4+vSpsFFQ586dlVYtUXB1dRUe/FXV6NGjhdfF2RyOiEgbVJ7zLZfLIZfLkZOTU+w/RFQ4mUymUj8jIyPh/0PFqMnkyZPxn//8B5cvX4azszMmT54Mb2/v0iy3XBk0aBAkEgmuXbuGDRs2ICwsDCtXrsSxY8eEhwE/+ugjYcv7efPm4eDBgzhw4ADWrl0rXGfEiBG4ePEievXqBQCoXbu2MKLetm1b4RcmxW6gAITr9+7dW2jz9fUFAKxevRr/+c9/lEZ8J02aBAsLiyK/nqpVq6r1fSgt7u7ueP36NeRyOVJSUtCxY8d8fV6+fKn0CY4qYmJi8PTpU7Rt2xaff/65yv+PERFpg0pzvo8ePVradeiV7OxsREVFKbVJJBJIJBIdVUSGTBGo864IkZOTg/PnzyM1NRVBQUHCuswxMTHo1q0bkpKSEBYWhqtXryqNCipeOzs7a/eLKGM+++wzXL9+Hd7e3qhTpw6mTp0qHPPz80OHDh2U1qU2NjYWXrdv3154HRoaCiOj3DGMjRs3onHjxsKxunXrIiwsDL6+vjAzMytya/eKFSsiLCwM9+7dU2o/ceIE7OzsMGTIEHz99dfo3r07unfvrtTn+PHjePjwIVq2bIlhw4Zh2LBhePjwoXB8/vz5WLhwIYDcEeFly5ap9D3Sps8//1x4XdjH8ZmZmZDL5SpPA3J3dxde//777/Dw8FD670ikS9z9u3wTyfmZnGDkyJFITEws8JiHhwc8PT21XBEZOkVInj59Or7++muhXbH838SJE7Fv3z4cP34cX3zxhdK53bp1Q3BwsFbrLYtWr14tfBpw9OhRfP/995g7dy6GDRuGsLAwpKamYtWqVZg9e7ZSQH716hUqVKig1T0LsrOzce3aNaxcuTLf/H7FDqIf8uLFC5iamuL8+fMICQmBv7+/8HN29epVtGzZslRq15b27dtj5cqVuH//vrAFvSq/bE6cOFHlOeREmvb+z+iMGTMwePBgHVVDpUGRIW1tbbFt27Yi+2pkh0tDY2VlBR8fH6U2jnpTafLz84Ofnx+A3LnaipUj7ty5g8TExHzBGwCDdyHc3NxgaWmJxo0b49atW2jXrh0AoHXr1qhRowZ27Nih1N/CwgI//PBDvuvoYvMjsViMNm3aCLtO5qXq30HVq1cHAGHvBSB3mcB///vfEIvFWLx4McRiMR4/fgypVFrocwT66vz580hOTsbQoUNx/vx5laeU7N69G3379kWVKlVKuUKiD+O4Z/nG8F0AsVgMR0dHXZdBBkwmkxX6sWPeJdsuXryorZIMwunTp1GxYkVhaoKbmxuA3LnbM2fO1GVpOpV3MCHvg7gZGRmoUaMGHBwc4OTkBAsLC/Tp0wcJCQk6qFJ1igdT27dvj927d6t0TnJyMlxdXZWmChHpip+fn9KnnVS+8G8golL21VdfISMjQ3ifkZEBFxeXMjfiqG09e/YUXit+GR45ciTCwsIQFhaGU6dOYevWrQD+eTjRysqqwDnBBQVvVVeZMWRmZmYYPHgwXFxcYGVlBbFYLHyv8oZ0Hx8ffPXVV0rnHj58WKu1Fqa4Aebx48dIT09XmhNORKRNHPkmAMj3wB8V7vTp0yovCaeY56d4iGz27NnCett5l5ijXNWrV8eLFy8AAAsWLEBWVhaCg4OxY8cOBAQEwMHBQehrY2MDGxsbpfOL8zNct25djdRsaNq3b4/Tp0/D1NQUixcvhlQqhaWlJRo2bIi2bdsKy1p+9NFHAIDmzZvjxo0bAHJXcYmJidFZ7aqYO3duvgfqVfXq1SvY2try70oiKhGOfBOA3NUGiruWbnk1a9asfG137txBeHg4rl69iqSkJKSnp+PLL78Ujru6uuKHH35Q2uiG8tu+fTsOHTokvF+4cCEuXrwIsViMfv36FbjbYUhICIB/Rr+p5KytrWFubg4AsLS0BJD76UPr1q3x559/KvVVLLMIoFibQOlK3uCdk5OjtCTkh/To0QPR0dGlUBURlScc+SbBmzdvdF1CmXPx4kWcPn1a2GSlMOnp6QgKCtJSVfrB3t4ejo6OSE9Px5o1a7Bw4UJMnDgRdevWhbOzM8aOHYuJEycKnw7s3r0b1tbWsLGxEX4RFIvFRS7RBwCVK1cu9a+F/pF31Dc4OBgmJiZYtGiRUp9q1arB1NRU70fB8z7IHB0djeXLl2POnDn46aefCp0XzgfliKikGL5JsHXrVmG3OfpHcnIy1q1bh/nz5wttQUFBsLS0xLx585CamqrD6vRPo0aNMG7cOFSrVg1169ZFTk4OKlSokG996YkTJwLInYqzdOlSpYecPxS4SbcWL14MoOAVWNasWYO2bdsiJycH6enp6NChg5arK77ffvsNAPDll18iKytL2M20oE9TOOWEiEqK/8KRIDIyUtcl6JXExEScPn0ajRo1wtGjRzF//nxh1YiClqYrzxQh5fXr1zAxMVFaG7ugIK0I3kDuR/nNmzcv/SJJY/I+jPm+tm3bAsjdmEgxZaWsyMrKUnrv7OwMd3d3zJs3T1i3d9CgQfjoo4+wbds2WFtbIzAwUNi5lIhIFZzzTeVeeno6pFKp8D4uLg7e3t4YMGAAVqxYIWz5/dVXX31weomhc3V1RYUKFfDzzz8DAI4dO6Z0XCKRqLQpTd7NTiwsLFCvXj3NFkp6xd/fX9clqO3w4cM4evSo0tfw9OlTBAUF4c8//8y3JwQR0Ydw5JvKlaNHj6Jhw4b4+OOPAeSOYN+7dw81atQQllNLTk4u8NxHjx5ps1S90r17d/zwww8wMzMT5veOHDkS9vb22Lhxo46rI3127NgxYefgX375BWPGjFE6vmDBAvz444/4+OOP8a9//Qt79+7VRZlFWrhwYb62lStXCq+vX78OOzs7mJqaQiQSoWrVqpyeQkSFYvgmJCUl6bqEUpWVlYWcnBycP38eCxcuxIABA3DgwAGlPtHR0Zzv/p7u3bvj5MmTAABfX998xydPngxAta29qfyyt7eHnZ0dDh06hFq1auH333+Hqamp8OCtq6srvvjiC5iYmCA5OVkvw/eHfPvtt3j37p1S27hx49C3b1+l1WDkcjnevXsHMzMzbZdIeqg4y9aSYWH4JqxevVrXJZSYXC7HkiVLUKlSJUyZMgV+fn64fPkyYmJiMGrUKNy6dQt//fUXAOQL3uVZ06ZNcevWLaW2ESNGYMKECcjKyoKXlxciIiJ0VB0ZCmNjY9SqVQsAhE+dFIyMjGBnZwdAeSCgV69eZWaa1/vBGwA2bdqEhw8fIiwsDG3btsXMmTPRvn17AMDly5fh6uqK06dPK42Qx8XFYdSoUeVuZaTyatasWVwitZxi+Cakp6cLrydPnlwm5mempKRAJpMJm6wcO3ZMWB96/PjxSltOK3ZBpNwNVM6fPy+837JlC2QyGaRSKTp16oSdO3eiTp06MDU1hampKSwsLFC1alUdVkyG7P1nBqpUqYJJkyYJU1PKSvgujGIN+uPHj+P48eNCe+vWrQHkhi+ZTIYVK1YAAN6+fYuXL1/i7du3Kj07QURlk96G7/T0dBw8eBARERGIiIiAVCqFl5eXyh/RZGVlYefOnTh79iykUinq1q2LoUOHclWFAuRdt1bfN9rJycmBsbExOnfuDCD3H7WNGzdCJpMJfRSrLVCuqlWrIiEhAQDg5+eHVatWITU1VZjbbmRkhMqVK8Pb2xt16tThR+KkNfb29krvLSwslOaEe3l54fnz59i3bx+A3IcfDWlb+DNnzgDInbo1d+5cNG7cGADQsWPHQkdEY2JicOHCBQwZMkRrdRKRZult+H7z5g12796NKlWqwMHBAbdv3y7W+WvWrMGlS5fQp08f1KhRA2fOnMGCBQvg6+uLRo0alVLVZVPe4JpXUlJSvu27tSktLQ3m5ua4dOkSjI2NcfLkSQQEBCj1cXNz01F1ZYNYLEZAQICwmYhIJMJ3331XYF/+Y076ZtiwYQCAffv2YcWKFahRowbc3d0xcOBA+Pn54ebNmxg/fjz+97//6bjSknv/uYrXr1/j7t27uHXrFl69egVnZ2f07NkTV69exerVq/HLL79g+/bt+Oijj3RUMRGpS2/Dt0Qiwfbt22FjY4PIyEhMmzZN5XMjIiLwxx9/YNSoUejfvz8AoFOnTpg8eTK2bdsmfMRXGJlMhpSUlA/ex8rKSuWa9FlhO7Z17dpVq/PRnJ2dhfsFBwdjzpw5GDZsmLABBhXMzMwMGRkZAHJ3iXR0dMTcuXNx8uRJBAUFwdjYGI0aNcKvv/6q40qJ1PP999+jffv2MDIywrx58wAAY8aMwR9//IFhw4YhNjYWQUFBcHd3x+HDh3VcrWa8/wB4QEAAFixYgFatWgHIHaBSfAowatQo/Pvf/xb6enp6IiIiApcvX4apqan2iqZie/jwIerXr6/rMkjL9DZ8m5iYqD3qeunSJRgZGSltBGFqaoquXbti+/btePnyJapUqVLo+UlJSRg6dOgH7/P+KKyhuHHjhrDutUwmK3SbZYW3b9/i7t27iIyMFEaq8tq7dy8GDhwIIyMjyGQyyGQyHD58GCtWrMC1a9dw//591KhRAwAwfPhw/P3338K5DN7KevTogRMnTgjvLSwsYGtrCzs7O6xbt06YMuLr66s0ksbgTWXZV199la+tVatWQhBdtGgRgoKCMG/ePDx58gQrV66ESCRCx44dtV1qqZLJZLh06VK+9q1btyI8PBwjR47EtGnTkJ2dDSB3YCUuLg6LFi2Cr68vrK2ttV0yfcDgwYP50GU5pLfhuyQePXqEmjVrwtzcXKld8ZT948ePiwzf5c37I9/jxo0TXufk5CiFb5lMhuPHj6NXr17IzMyEsbExOnbsiEGDBmHfvn1C+E5ISIBEIsGdO3ewfPlyuLu749ChQ/k+dZg9ezZOnTolvM8bvEnZ1q1b0aRJE/zwww/w9/fHrl27cPbsWWRlZaFChQq6Lo9IpxQPZ27atElo27RpE2rXro3u3bvrqiytuX79Oq5fv67UNmLECDx+/Bg5OTno0qULfv31VzRq1AgpKSmIi4uDk5MToqOjYWZmprQkIhGVLoPc4fL169cFjpor2hQbPhii2bNn4/Xr1yr19fLyQlpaGi5evFhon1atWmH//v1ITExEVlYWfHx84OPjA7lcjkGDBgnzhxUPRJ09exY//fQT3NzcMGHCBGEnw9atWxc43Sdv8Kb81qxZAz8/P7i6uqJJkyYAgAoVKuC7775DYGAgjIyMGLyJgALDY/PmzYXR3rNnz6JBgwbYuXOntkvTmaioKOTk5AjvT5w4gYyMDMycORPjx4/Hjh07MHDgQPTq1QsymQzR0dEAcgdZsrKySnTvwjYrIyIDHfnOzMyEiYlJvnbF3LfMzExtl6QVISEhOHXqFEaNGgWJRJLv+PPnz3Ht2jX4+vrC1tYWiYmJKo00L1u2DMuWLVNq+/zzzwEAz549U2qfMWOG8Do8PFydL6Pc6tmzp9LSawEBAahevToAoEOHDvn6c6SK6MOMjY1x7tw5WFpaYteuXQByHzwu7FkXQ7Zr1y7hewDk/nKv4OLiAiB3itqOHTtw6tQpjB07FhMnTiz2feRyObp06YLz58/DwsKi5IUTGRiDDN+mpqYF/tauCN0fegDFxsYG69evL5XaSlPebb6fPn2Kn3/+GXXr1kWLFi1w69YtbNiwQTiuGP1X5y9W0pwdO3YIzxcsWLAACxYsQHBwMAIDA4XgTUQlY2lpqfR+165d+PrrrwEA06dPR4cOHdCrVy9dlKZ3RowYIbzevHkzMjIyEBQUhMTERBw/fhxRUVGoVKmS8Enc+549eyasTvbrr7/im2++wbt37yAWi2FsbKyVr6GsUazsRepJTU1FREREmVpK2iDDt0QiKXBqiWL3NFtb2yLPNzIyKnMrmdy6dQuPHj0CkPuke15550CSftiwYQO++eYbmJmZwcXFBW/evBGOdevWjVvdE5UiR0fHfA+5hYWFISwsDFZWVkhISICXl5eOqtMvO3bsEF7nXdp18uTJMDU1xcWLF+Hm5gY3NzcYGRmhb9++6N27NwAgKCgIffv2xbfffouvvvpK+IWHlLm5ueHcuXO6LqPM+vPPPzF9+vQy9eCqQc75dnBwwLNnz5CWlqbU/uDBA+F4WfP06VOMHz8+X/vs2bPx7NkzjB49WgdVkSry/uP16aefwtTUFC4uLli+fDlq1KiB8ePHC3PjiUh3nJ2d0aBBA7Rp00Zpl1zKz9/fH6tWrUJoaCh8fHzg4uICZ2dnAP+sBPbixQv07dsXMTExiI2NVdpNmf4hlUqxdu1ara/uNWrUKIOYfqV4VqEsKfPhOyMjA7GxsUrrcrdp0wYymUxpSbasrCycPn0aTk5OZXKlk1evXglPsstkMixZsgRDhgzBqVOn0LdvXx1XR3mNHz8en376KYYPH46wsDA0bNgQYWFhcHBwQN++fYV53Z06dYKpqSn+9a9/FTinm4h0VO14+AAAH/NJREFUx9HREVeuXMG1a9d0XYpB2LNnD9q1a4enT59i4cKFmDhxIpydneHn5ydMvUtNTS1wymhcXJzK95FKpcJSi2XJlStXsHbtWq3e8/bt2wbxALK/vz8AYP/+/TquRHV6Pe0kMDAQqampwhSS0NBQ4XWvXr1gYWGByMhIzJkzBx4eHsJ0CycnJ7Rp0wbbt29HSkoKqlevjpCQECQkJGDKlCk6+3o+RC6XQyQSAQDu3LkDqVSK5ORkNG7cWBgZVYwskO5ZWFhg27ZtGDRoEGbPno2wsDBkZ2dj9OjRBX5KsWPHDpiYmHxw3XQi0g+KB/cvXbqEFy9eoG7duli0aBGOHDkCAFixYoXSQ+b0YYqNgRQUnzAEBgZizZo1SE5ORlBQEExMTPDkyRNkZ2djwoQJmDdvHtzd3XHz5k2sW7cOW7ZsKfD6w4cPR//+/TF06FCsX78elStXVprHrq+ioqJ0cl9Nrf525MgRfPHFFzpdCGDZsmUYOHCgzu5fHHodvg8dOoSEhATh/ZUrV3DlyhUAuas/FPUU9bRp07Bjxw6cPXsWUqkUdevWxfz589G4ceNSr7u4xowZg5UrV6J3795Yu3Yttm3bhsuXL+u6rHJtzJgx+OWXX5TaLCwskJqaiqlTp6JevXpo3bo1AAjzzAYMGFDkNbkkIFHZVKFCBdStWxcA8MMPP2DQoEGwtrZGtWrV0LlzZ5w5cwaHDx/OFyxJdT4+PsJrV1dXODg44PHjx0Lb4sWLIRaLkZ2djVu3biEjIwORkZFo3LixMGiVk5ODmJgYrFmzBkOHDsXt27dhbGys8/BdnJH4uLi4Ug2wT548gb29vfCJed6lKEti0aJFWLx4sdLmhqpITEzE9u3b4e3trZE6hg0bho4dO6JXr16oWrWqRq5ZGvQ6fL8ffgrSpEmTAneaNDU1xejRo8vEXOjw8HB06dIFAAocMSXtqlWrFiZNmoSUlBThY6zKlSsjJCREx5URkT5o2LCh8Fomk6FNmzb59pZQbDxG6skbvBXyBvS2bdsqHZs8ebLSaip5PyUOCQlBq1atULFixSLvGR4ejmbNmqlZceFiY/+vvXuPirrM4zj+Hm4CglwVDUVSSDTF+y2zEi9J3nOjlbUNN12PSkmappllaldbL61WmqklZbVW6mqlW1qGN2SP5mZokZdcb6UgKeoKDPsHh1+MgynMMDPA53UOR+Z3fWa+/ma+PPP8vs+xG962f//+bNiwgbCwsAqda/LkycTExFwz97m6k6h0B6etjh49avx+6tQp1q9fX+b9TCdOnDBmtS6ZAOtGk+/Vq1db9G6XPidAZmYmmZmZNGvWzKWTb33/LTVWyfCP3r17k5ycbCwvebOYNGkScXFxfPzxx0q8RaRM48aNIyUlxZj8avz48fj7+/P4448b93d88MEH9O/f/7rfjknFLVy48JpjpidPnkz37t3p0KGDRVJ+5swZzp8/z9y5c9m1axcPPfQQUHyPWHnGmV9PeW9q7NevH9OmTavQkKbNmzdblBUu7cKFC1bLPv/8c6D45ti8vLxyn6+0N954g4KCAsxmMz/88INR/vjSpUvk5eUZ5Z4HDhxITk4Oc+fOtTrG0aNHiY+PNx7n5ORw8eJFI3YvvPACQ4cOZdu2bWzatKnMzlfAarZXV2Mqqg63utpJUlISZ8+eJSQkhBUrVjjsvBrH7RglX1kuW7aMkydP0r59e9LS0iy+Kj59+nSFexxERH7++WeOHTtG+/bty1w/duxY/vjHPzJhwgSL5b169TISIal8SUlJrFixgscee4yXX37ZWL5p0yaj1Gt8fDwzZsxg2bJlNGnSBLPZTOvWrS16VLt06UJISIjFBGn5+fkWE/0dOnSIhISECrd1586deHiUPVDh2WefJTQ0lGPHjjF79mwjn4iPj2fixIn4+fmxY8cO/P39GTNmzO/OXDpu3DgaN27MrbfeSnBwMPn5+dSqVQt3d3f27t1LmzZtgOK65AUFBYwZM4ZXXnnF6L0ubfbs2Tz55JNWyxcvXszo0aOtlvv5+ZGYmEi9evWYPXs27dq1o0+fPlYT/JWHo0sPlieHVPJdipLv6mPIkCFkZ2eTlZWFj48PWVlZPP300/j5+dG5c2dNaCAiTtWhQweLSbbeffddo2jAxx9/TKNGjaw+G5SgO563tzeXL1+2WBYVFUViYiK1a9fm8ccfB35L9BISEjh06BAff/wxDRo0wMPDw+bkG4qHpF68eJGEhARjyEZ+fj5du3YlPDyc48ePWw3JgOLhHPPmzbPp3CWee+45ZsyYYTFLeOfOnV22IpArJ98uPeZb5EbUr1/f+Ipw6tSp9OjRg+DgYGP97t27CQoKIioqyllNFBGxUnrsuJeXFy+//DLnz5+nUaNGwG+Tcc2cOZOnnnqK2NhYJd8OdnXiDcWVSWbOnGm1rPQkQkOGDAGKq1ydP3/e5nYsWbLEON6IESO47777jEmPjh8/DlBmpQ97Jd4ATzzxhNUyV028XZ2Sb6ky2rRpw969e43HK1asYNeuXQwfPpxu3bqRlpaGt7e31X4dO3Z0ZDNFRK6rJDkr4e7ublXvv1OnTqxatYrw8HD8/PxISEjAZDJx4cIFFi9ezPTp05k1a5YDWy3Xcq3ZO0u+2bCn5cuXs3z5crsfVxxHybc4TEhISIVqig4ZMoRx48YRGBiI2WymU6dOTJkyhZYtWxqlI5OTk8tMvEVEXNG0adOA4rKm586ds/i2rrTo6GgAY/rxYcOGGevatm3L/fffz/vvv1+5jRURu1K1E3GImJgYEhMTCQgIMJaVrtNe8vXrqFGjLMZp9e7dm5SUFAIDA4HfKpRc/fVaUlJSZTVdRKTSjBkzhqlTp/7uvBVlGTVqFBEREaSkpLBp0yZuueWWSmqhiNiber7FIVJTUzl9+jStWrXi9OnTTJ8+nY0bN7J3716Sk5NJSUkhLS3NuAu6d+/ePP/882Uea9SoUY5suoiIy/L09CQ4OJjOnTsTFxfHQw89pKF2Ii5OPd9iF6XrYD/wwAMsXboU+O0rU4CwsDDatWtH165deeWVV/D29qZLly5AcZmhlJQUY9trJd5AmWWKRERqsvHjxzNy5EhMJhOrVq0iNjaWW2+91Wq7kuocIuI86vkuQ0FBAVlZWRbLgoODrzkmryaIjIzkyJEjxuP4+Hg+/fRT43GdOnUAWLNmDQ0bNiQrKwt/f38WLVpkVVc0MDDQmJodYNu2bZp6XUTETqKjo1m0aBFXrlzhm2++YcKECWRkZDB//nxiYmLo1KkT6enpzm6mSI2lOt+llNRoLMuwYcOMGqz25mp1vj/55BOjhNGXX37JXXfdxVdffUWtWrXo0qULq1evpnHjxnTs2JHNmzfzv//9j7p163Lq1Cnq16/v5NaLiEhpZ86cITQ01Hj8zTffGLM5ljZ27Nhrzo4oUtW4cp1vDTspQ0BAAPPmzbP46du3r7ObVWlKJpxp0qQJw4YNo169eqxZswYoHg6ybt06ateujYeHB7t27SIyMhKTyUStWrWoU6cOdevWBVDiLSLigkon3gCtW7c2qq2UTM+9dOlSo1yeu7s7b731lrF9WYm6iFScku8yeHh4EBUVZfFTVYacuLu7WzxevHixxePnn3+ejz76iNdffx1vb28SExPZunUrAB988AETJ04EoGHDhkYCXjKb1tXH37ZtW6U8BxERqVwldcZDQkKA4nkUSjpidu3aZTFe/N5773V8A0WqMSXfLqBt27Y2H6Nr164AbNiwASgee/3II4/Qvn17pkyZAsDNN99Mr169iIiIoEOHDqSlpTFhwgQAPvvsM6tjNmzY0OZ2iYiIa9qxYwcmk8liWVpamvH7kiVLWLBgAWFhYdx3332A5WQy9vjsEqmJlHy7gPnz5wPQrFkzq3UvvvgiAO+99x6tW7cG4MEHHwSKZz9bv349GRkZjB8/nlq1ahEaGsqWLVto2LAhf/7zn4HimyPnzZvH8uXLrd5oS1z9taSIiFRvnp6eeHh4GB00gMVkZe3ataNbt25A8WdESEgIY8eO5b333uPzzz9nyZIlLFy4kLCwMFq0aOHw9otUVap24gJq167Nzp07uXz5MnfddRdDhw5l9OjR9OnTh549ewIQFRXF0KFDadeuHWPGjOGtt96yuDEmKirK6LHw9/e3On737t0d94RERKRKMJlMVpOWlaVbt24EBQXh6+tLVFSUsbxLly5s2LCBoqIiPvzwQ2JjY/H39+fEiROMHj2a9u3b061bN1555RVWr159Q+cSqYiAgAByc3NJSkriiy++cHZzfpd6vl2Eh4cHfn5+TJ48mQceeIDg4GDjTt0RI0YAcM899zBu3Djc3NzYsWOH1TGu1astIiJii5iYmN8d+12SxN9yyy00aNCA9u3bA8X3HcXFxQHFJWtL3zdUeh6IEp6ennZuuVRFO3bsIC0tzWJW7BKzZ8+2Wta9e3cGDhzoiKbZhZJvF5OQkGA11nrcuHFW2+kNSkREXFnJOPH69evz2muvARAeHm6sL6mQVbok3EcffeTAFoqrCQoK4tlnn8XT0xNvb2+jB/vTTz8lPT2djIwMo/rcs88+a1Tt+dvf/kZycrLT2l1eSr5FRETE7kpm0/Tw8DCmvP/ggw/YvXs3GRkZDBo0yGL7OXPm0KBBA9544w2LJP1aSgoGlDZ9+nQ7tFyup2XLllbLSk+WVzJXCMCsWbNYtWoVw4cPB4qTZoDPP/+cjIwM4/9Gybq7777b4rhvv/02devWxc3tt5Q1PT2du+++m7Zt2xIfH4+bmxvu7u5MmjSJli1bGkN2XZXGfIuIiIhDeHj8lnb4+voa5Q09PDyIiIgAiquorF27luXLl/P111+zb98+Bg0axNq1a5k2bRqtWrUyxp3PnTvX4vglhQmkcoWHh5OSksKyZcvYvn07UFwpZ+bMmYwZM4Z69eqRl5dHYWEh8fHxAKSkpJCamkrnzp2ZOHGiMaSk5FuRaynrZt6SRDwyMpJZs2YZy++//34A7rrrLpufY2VSz7eIiIg4XMeOHdm0aRMA27dvp2nTphbrR4wYwbJly8jIyGD69OmsXbuWQYMGWdzw+fXXX1vsExYWZtQwX7RoUSU/g+rDx8fH+D0lJcX4PT09ndq1axuPhw8fTvPmzUlOTqZNmzbEx8fzl7/8hU2bNmEymXj66aepV68eAP369aN///4W5wkLCyMwMJBhw4bV6PvUlHyLiIiIw5lMJqO0YekhBdcSHh5utZ2Pjw8fffSRUZjAx8eHoqIiWrRoQefOnZk7d65xI15qaioAvXv3JjY21qKmua1efvllAHr27GkxZKZHjx52O8f1TJ061eJx6YS69B8spZWUmdy6davxLURiYiKrV68mIyMDNzc3HnnkEWN7k8nEypUradCgAVBcynjs2LFlTkQYFxdHr169LJaVzEVS0yn5FhERkSorIiKCxMREY4bmqKgoWrVqBcAdd9xBnz59iI2NJSYmhnXr1jF58mReeuklY/9//etfhIaGMmrUKADefPNNwsLCaNSoEQ8//DCARe/v1RITE41yvi+++KJFz/Ff//pXi23ffvttq/2feuqp6z7H1atXG793796dAQMG8OSTTzJp0iQjwe/bty9Lly4FIDk5GbPZbMwLUjKT6dChQxkwYAC7d++mQ4cOxkRJJpPJmO3azc2NyMhI43yDBw8mLS2NBx98kNjY2Ou2Va5PY75FRESkSgsKCmLYsGGA5SycUFyLvEuXLgDcdNNNxnKz2cz48eMJCgpi+fLl+Pv7c+7cOZo1a2bRQ9unTx8SEhIA8PLy4sqVK0DxrNHTpk2jTZs2AKxbtw6w7HGOjo5m8ODBrFmzhnvuuafM8cs9e/bk5MmTDBs2jOTkZL777jurbYKDgxkwYACbN29m3rx5FutK2mYymWjTpg1TpkzhD3/4A9nZ2XTv3p0xY8YAcPbsWSMJN5lMvP766wDG0B/4rQJNae7u7ri7uxt/iIjtTEVFRUXOboSrSEpKMv5zrlixwtnNERERERewc+dOkpOTSU9PZ+nSpTRq1Mi4kfBqRUVFFBQU0LVrVzIyMvjyyy957LHHeO+994zhH1lZWdSpU4eioiLCwsIs9u/QoQMZGRnk5+dz8OBBtm3bxujRoyv9OYptypNDKvkuRcm3iIiI2ENubm6Zk8RcT15e3u8OcxHXVJ4cUmO+RUREROysIok3/P74cqkelHyLiIiIiDiIbrgsQ0FBAVlZWRbLgoODyyylIzcmNzfXmN2qRGpqaoV7BsS1KL7Vm+JbfSm21Zvi65qUfJchNzeXRx991GLZsGHDSExMdFKLRERERKQ6UPJdhoCAAGbMmGGxTL3eIiIiImIrJd9l8PDwuOZsUCIiIiIiFaUbLkVEREREHETJtwvIzs7m3XffJTs7u1qf05mc9Xxr2nmdpaa9zjUpvjXtNa5JsYWa9zorvtXznOWl5NsFZGdns2rVKof/53T0OZ3JWc+3pp3XWWra61yT4lvTXuOaFFuoea+z4ls9z1leSr5FRERERBxEybeIiIiIiIMo+RYRERERcRBTUVFRkbMb4SoGDx5MYWEhbm5uBAUFOey8BQUF5ObmEhAQgIeHY6o/OvqcZrOZnJwci2VBQUG4uTnm7z9nvMY16byKb/U+rzPjW1NeY2edV9du9T5vTYyvs2Kbk5OD2WzG3d2dNWvW/O62Sr5LGTRoEGaz2dnNEBEREZEqyM3NjbVr1/7uNppkpxRPT0/y8/MxmUwEBgY6uzkiIiIiUgWcO3eOoqIiPD09r7uter5FRERERBxEN1yKiIiIiDiIkm8REREREQdR8i0iIiIi4iC64VIqXX5+Pu+88w5btmzhwoULREZGMnz4cNq2bVvuY73//vukpqYSERHBokWLKqG1Ul62xPf7779n8+bN7Nu3j59//hl/f3+aNWvGAw88QHh4uANaL2BbDO15fUvlqGiMdH26Pntdf/psdSz1fEulmz9/PmvWrOHOO+9k1KhRuLm58cwzz7B///5yHefMmTP84x//wNvbu5JaKhVhS3w//PBDtm/fTuvWrRk1ahR9+/Zl//79pKSkcPToUQe0XsC2GNrr+pbKU9EY6fp0ffa4/vTZ6niqdiKV6vvvv2fixImMGDGCe++9F4ArV66QnJxMQEAAc+bMueFjvfTSS+Tm5mI2m/n111/117kLsDW+mZmZREVFWZRmOnHiBMnJyXTr1o2JEydWavvFthja8/qWymFLjHR9ujZ7XX/6bHU89XxLpdq2bRtubm707dvXWObl5UXv3r05cOAAv/zyyw0d59tvv2Xbtm2MGjWqspoqFWBrfJs3b25VE/Wmm24iIiKCY8eOVUqbxZItMbTX9S2Vx5YY6fp0bfa4/vTZ6hxKvqVSHTp0iPDwcHx9fS2W33LLLQAcPnz4uscoLCxk8eLF9OnTh8jIyMpoplSQPeJ7taKiIs6dO0edOnXs0kb5fbbEsDLiL/Zl7xjp+nQdtsZWn63Oo+RbKlV2djZBQUFWy0uWnT179rrH+Oyzz/jll18YPny43dsntrFHfK/25ZdfcvbsWbp3725z++T6bIlhZcRf7MveMdL16Tpsja0+W51H1U7khpnNZgoKCm5oW09PT0wmE1euXClzqlUvLy+geHza7/n111955513uP/++wkICCh/o+WGOSO+Vzt27Bivv/46MTExxMXFlWtfqRhbYmjv+Iv92TNGuj5diy2x1Wercyn5lhu2f/9+nnjiiRva9tVXX6VRo0Z4eXmRn59vtb7kTaHkTeJaUlNT8fPzo3///uVvsJSLM+JbWk5ODjNnzsTX15cpU6bg7u5+w/tKxdkSQ3vGXyqHvWKk69P12BJbfbY6l5JvuWENGzZk/PjxN7RtcHCw8W9ZX33l5OQAEBIScs1jnDhxgo0bNzJy5Eiys7ON5fn5+RQWFnL69Gl8fX3x9/cvz9OQa3B0fEvLy8tjxowZ5OXl8cILL9zwfmI7W2Jor/hL5bFHjHR9uqaKxlafrc6n5FtuWFBQEL169SrXPjfffDP79u3j4sWLFjeFHDx40Fh/LWfPnsVsNrNkyRKWLFlitX7kyJEMHDhQd2nbiaPjW+LKlSvMmjWL48ePM3v2bCIiIsrXcLGJLTG0R/ylctkaI12frquisdVnq/O5z5gxY4azGyHVl6+vLxs3bsTf35/mzZsDxX9dL1y4kPDwcIYMGWJse/nyZU6ePAmAt7c33t7exMTE0L17d4ufo0eP4uXlRUpKCq1btyYwMNApz01siy8U323/4osvsm/fPp544gliY2Md/yRquBuNYVnxK0/8xTlsia+uT9dW0djqs9X5lHxLpQoNDeWnn35iw4YNXLp0idOnT/Pmm2/y008/MWHCBOrVq2dsm5mZyYQJE6hVqxatWrXC29ubRo0aWf2kpaVhNpsZPXq03hyczJb4Arz55pts3ryZjh07Ur9+fY4cOWLxo57TynejMSwrfuWJvziHLfHV9enaKhpbfbY6n4adSKWbMGECqampbNmyhQsXLhAZGclTTz1Fy5Ytnd00sQNb4nvo0CEA0tPTSU9Pt1rfo0cPu7dXrNkSQ13frq+iMdL16fp0/VVNml5eRERERMRBNMmOiIiIiIiDKPkWEREREXEQJd8iIiIiIg6i5FtERERExEGUfIuIiIiIOIiSbxERERERB1HyLSIiIiLiIEq+RUREREQcRDNciohUQQMGDLB4bDKZ8PX1pXHjxsTFxdGnTx9MJpOxft68eWzevJnnnnvOmD5cREQcT8m3iEgVFhcXB4DZbObUqVNkZmby3XffsW/fPiZNmuTk1omIyNWUfIuIVGGPPvqoxeM9e/bwzDPPsHXrVu688046derkpJaJiEhZNOZbRKQaadu2LT169ABg586dTm6NiIhcTT3fIiLVTJMmTQA4c+ZMmeu//fZbVq1axQ8//ADArbfeyogRI4iIiLDY7sKFC2zZsoXdu3fz3//+l5ycHHx8fIiOjmbw4MG0bdvW6tiXLl1i/fr1bN26lZ9//hmz2UxgYCBNmzalT58+tGvXzmL7y5cv889//pO0tDROnDgBQOPGjYmPj6dnz542vxYiIq5GybeISDVz6dIlADw9Pa3Wpaens27dOqKjo2nfvj2HDx8mIyODgwcPsmjRIoKCgoxtDx48yJIlS6hXrx7h4eHExMTwyy+/sGfPHvbs2cPDDz9M7969je0LCwuZPn06Bw8epE6dOrRq1QpPT0/Onj1LRkYGtWrVski+z507x/Tp0zly5AhBQUG0bNmSoqIiDhw4wPz588nKymL06NGV+EqJiDiekm8RkWqkqKiI3bt3AxAZGWm1ft26dUyZMoWuXbsCxQnzSy+9xPbt29mwYQPDhw83tg0PD2fOnDnExMRYHOPHH39k2rRpLF26lNtvvx0fHx8A9u/fz8GDB4mOjuaFF17Ay8vL2OfixYtGz3aJBQsWcOTIEQYOHEhSUpLxx0JOTg4zZ85k/fr1dOjQgfbt29v+woiIuAiN+RYRqQYKCws5ceIECxYs4MCBA3h6etKrVy+r7e644w4j8QZwd3fnvvvuA4qT59Lq169vlXgDNG3alH79+nHx4kX+85//GMtzc3MBaN68uUXiDeDr60tUVJTx+NChQ2RkZBAdHc1DDz1k0UsfFBREcnIyAJ9++ukNvwYiIlWBer5FRKqwq+t9A/j4+PDoo4/SoEEDq3VljdO+6aabgOIe56sVFhbyzTffcODAAbKzs8nPzwfg5MmTABa92U2aNMHNzY0vvviCiIgIunbtSp06dcps9549ewDo0qULbm7W/UBNmzbFx8eH77//vsz9RUSqKiXfIiJVWEmdbzc3N2OSndtuuw0/P78ytw8JCbFa5uvrC2Ak1iXOnDnDzJkzOXz48DXPXzK+HIqHqSQlJfH222+zcOFCXn31VSIiImjdujU9e/bk5ptvNrY9ffo0ACtXrmTlypXXPP6VK1euuU5EpCpS8i0iUoVdXef7esrqZb6Wv//97xw+fJjbbruNoUOHEh4ejo+PD25ubnz22WcsWrSIoqIii32GDBnC7bffzs6dO9m7dy/79+9n7dq1rFu3jpEjRzJw4EAAY78WLVpQv379cj0HEZGqTMm3iIhYuXz5Mnv37iUwMJDJkyfj7u5usf7UqVPX3Ldu3boMGDCAAQMGUFhYyNatW1mwYAHLly8nLi4OPz8/QkNDgeJhJ0OGDKnU5yIi4kp0w6WIiFjJy8vDbDYTHBxslXgXFBTc8AQ+7u7u9OjRg+joaAoKCowx4m3atAFgx44d9m24iIiLU/ItIiJWAgMDqV27NkePHuW7774zlhcWFrJixQqOHz9utc++ffvYu3cvZrPZYvmpU6c4duwYJpPJGHPerFkz2rRpQ2ZmJq+99hoXL160Ot7hw4f597//bednJiLiXBp2IiIiVtzd3bn33ntZuXIlU6dOJTY2Fn9/fw4ePMi5c+fo168fGzZssNjn8OHDLF26lICAAJo2bUqdOnXIzc3l22+/JT8/n/79+1vc8Dlx4kSefvppPvnkE7766iuaNGlCcHAweXl5HDlyhDNnzjBw4EDV+RaRakXJt4iIlCkhIYHQ0FDWrl1LZmYmXl5etGjRgj/96U/8+OOPVtt37NiR8+fPs2/fPo4cOcKvv/5KQEAALVq04J577rGoLw7Fvetz5sxh48aNfP311xw6dIjMzEwCAwOpX78+AwYM4I477nDU0xURcQhT0dW3qouIiIiISKXQmG8REREREQdR8i0iIiIi4iBKvkVEREREHETJt4iIiIiIgyj5FhERERFxECXfIiIiIiIOouRbRERERMRBlHyLiIiIiDiIkm8REREREQdR8i0iIiIi4iBKvkVEREREHETJt4iIiIiIgyj5FhERERFxkP8D77e8CcZWG8oAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "lc.fold(mProt.LS_results['avg_period_days'].data[0]).plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That looks nice! (And so do those flares!!)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 Fitting Flares" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In $\\texttt{stella}$, we use a very basic model flare fit of a sharp rise and an exponential decay. This can be done through a class included in the code. The first thing that needs to be done is get predictions for where the flares occur. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "MODEL_DIR = '/Users/arcticfox/Documents/flares/run01/'\nMODEL = [os.path.join(MODEL_DIR,i) for i in \n os.listdir(MODEL_DIR) if i.endswith('.keras')][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: No stella.DataSet object passed in.\n", + "Can only use stella.ConvNN.predict().\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1/1 [00:00<00:00, 1.16it/s]\n" + ] + } + ], + "source": [ + "cnn = stella.ConvNN(output_dir='.')\n", + "cnn.predict(modelname=MODEL,\n", + " times=lc.time,\n", + " fluxes=lc.flux,\n", + " errs=lc.flux_err)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, now we have a light curve with predictions from just one of the $\\texttt{stella}$ models." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(14,4))\n", + "plt.scatter(cnn.predict_time[0], cnn.predict_flux[0], c=cnn.predictions[0], vmin=0, vmax=1)\n", + "plt.xlabel('Time [BJD - 2457000]')\n", + "plt.ylabel('Normalized Flux');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can initiate our flare fitting class, `stella.FitFlares`, and start fitting those flares!" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "ff = stella.FitFlares(id=[lc.targetid],\n", + " time=[lc.time],\n", + " flux=[lc.flux],\n", + " flux_err=[lc.flux_err],\n", + " predictions=[cnn.predictions[0]])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The flares are identified given a certain probability threshold (here, I use a threshold of 0.5, which is what was used in [Feinstein et al. (2020)](https://arxiv.org/abs/2005.07710)). For the cleanest sample of flares, one could explore a higher probability threshold.\n", + "\n", + "Several parameters about the flare are returned in an astropy Table:\n", + "- tpeak: the peak time of the flare\n", + "- amp: the amplitude of the flare\n", + "- dur_min: the duration of the flare, given in minutes\n", + "- rise: how quickly the flare goes off (this is very fast and generally the same across all flares)\n", + "- fall: the exponential decay\n", + "- prob: the probability at the tpeak time" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Finding & Fitting Flares: 100%|██████████| 1/1 [00:00<00:00, 3.06it/s]\n" + ] + }, + { + "data": { + "text/html": [ + "Table length=16\n", + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Target_IDtpeakampdur_minrisefallprob
float64float64float64float64float64float64float64
62124646.01656.45766947437780.00517271866554260139.0307026803608960.00010.00688458976865427650.9807868599891663
62124646.01657.31324338198560.00935070228511011346.0427474926023450.00010.005440531357077170.9993744492530823
62124646.01659.18828153893080.0165110534040283139.068943053366020.00010.0048665709253705070.9999998807907104
62124646.01659.93274023421740.00531299853780956839.0434203414553450.00010.0099615092212989240.6145604252815247
62124646.01661.35915489099530.01616045832644144640.07148748342360.00010.0054786545406301720.9998658895492554
62124646.01664.60226137635350.0192907510039818140.1231279321261950.00010.0083774666962270731.0
62124646.01665.10504612819890.01314713709421687539.0896531890076840.00010.0080857918850959530.9999781847000122
62124646.01671.53841797829930.02035861226105141839.1231058612179940.00010.0077604368901831541.0
62124646.01673.18702736909740.0205590406398600839.114627785012330.00010.007054779840450441.0
62124646.01676.2536836973380.03055554684541682339.214232149922520.00010.0090138280819179881.0
62124646.01676.95506884504040.00673877124922315639.025499944224180.00010.0046305339257480510.997788667678833
62124646.01677.32451111334220.2810143935238597640.429627767115780.00010.0065647640076292621.0
62124646.01677.79534147014150.00859558528051674539.04217474905530.00010.00624890500430893250.9562909603118896
62124646.01679.16477600030750.006115484082584130539.035647558860110.00010.00713760243215867150.9747272729873657
62124646.01679.5717171545920.00905349498155829339.06350144752650.00010.0088848388797201030.9999923706054688
62124646.01681.73419719783940.01064266441690119239.0321765605989060.00010.0034022541541514470.9999966621398926
" + ], + "text/plain": [ + "\n", + "Target_ID tpeak ... fall prob \n", + " float64 float64 ... float64 float64 \n", + "---------- ------------------ ... --------------------- ------------------\n", + "62124646.0 1656.4576694743778 ... 0.0068845897686542765 0.9807868599891663\n", + "62124646.0 1657.3132433819856 ... 0.00544053135707717 0.9993744492530823\n", + "62124646.0 1659.1882815389308 ... 0.004866570925370507 0.9999998807907104\n", + "62124646.0 1659.9327402342174 ... 0.009961509221298924 0.6145604252815247\n", + "62124646.0 1661.3591548909953 ... 0.005478654540630172 0.9998658895492554\n", + "62124646.0 1664.6022613763535 ... 0.008377466696227073 1.0\n", + "62124646.0 1665.1050461281989 ... 0.008085791885095953 0.9999781847000122\n", + "62124646.0 1671.5384179782993 ... 0.007760436890183154 1.0\n", + "62124646.0 1673.1870273690974 ... 0.00705477984045044 1.0\n", + "62124646.0 1676.253683697338 ... 0.009013828081917988 1.0\n", + "62124646.0 1676.9550688450404 ... 0.004630533925748051 0.997788667678833\n", + "62124646.0 1677.3245111133422 ... 0.006564764007629262 1.0\n", + "62124646.0 1677.7953414701415 ... 0.0062489050043089325 0.9562909603118896\n", + "62124646.0 1679.1647760003075 ... 0.0071376024321586715 0.9747272729873657\n", + "62124646.0 1679.571717154592 ... 0.008884838879720103 0.9999923706054688\n", + "62124646.0 1681.7341971978394 ... 0.003402254154151447 0.9999966621398926" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ff.identify_flare_peaks(threshold=0.5)\n", + "\n", + "ff.flare_table" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cool! We can mark all of our flares as well, just to see them better by-eye:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2EAAAEoCAYAAADRxPmyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdd3gc1bnH8e87W9Qtucjd4IbpYGoMcehySSCUYExvIdxwQ3JTSJxyKYEQIAESShpJqCEEllwgQIhZuoFQQjPVxtjGttxl9ba7M+f+sWtbNm5rSavi3+d5FmlnZ8+8IwvtvHPOeY855xAREREREZHc8Lo6ABERERERkR2JkjAREREREZEcUhImIiIiIiKSQ0rCREREREREckhJmIiIiIiISA4pCRMREREREckhJWEiIiIiIiI51C2SMDM72cxuMbNZZlZnZs7M/rId7VxnZk+b2WIzazazNWb2lpldbmb9OyN2ERERERGRbFh3WKzZzN4G9gUagCXAbsC9zrkzs2wnAbwJfACsBIqACcCBwFJggnNucQeGLiIiIiIikpVwVweQ8R3Sydc84HDg2e1sp49zrmXjjWZ2NfBj4EfAf29vkCIiIiIiIu3VLYYjOueedc597NrZLbepBCzjgczXXdrTvoiIiIiISHt1iyQsB47LfJ3dpVGIiIiIiMgOr7sMR+xQZnYJUAyUkp4PNpF0AnbtFt5zBXB5LuITEREREZEdg3PONt7WK5Mw4BJgUJvn/wLOdc6t6qJ4REREREREgF6ahDnnBgOY2SDgUNI9YG+Z2bHOuTc78DifyWq7g0yv3gacc5/Z1l3bz6WOPpfu/LPpzrH1Btvz89W/ifRUPfF3tyfG3F115M9yW9vqLX9js4mpO8bfWXrruZrZZutd9Oo5Yc65Fc65h4BJQH/g7i3se4VzzrblkbMTEBERERGRXqdXJ2FrOec+Jb122J5mNqCr4xERERERkR3XDpGEZQzNfPW7NAoREREREdmh9bgkzMwiZrabmY3ZaPs4MyvdxP5eZrHmgcDLzrnqXMUqIiIiIiKysW5RmMPMTgBOyDwdnPl6iJndmfl+tXPuksz3w4APgU+BkW2a+SJwjZm9CCwAqkhXSDwcGA0sB77WSacgIiIiIiKyTbpFEgaMB87ZaNvozAPSCdclbNlTwFjSa4LtB5QBjcBc4B7gZufcmo4KWEREREREZHt0iyQsU4Lyim3cdyHwmQqFzrn3gIs7Mi4REREREZGO1uPmhImIiIiIiPRkSsJERERERERySEmYiIiIiIhIDikJExERERERySElYSIiIiIiIjmkJExERERERCSHlISJiIiIiIjkkJIwERERERGRHFISJiIiIiIikkNKwkRERERERHJISZiIiIiIiEgOKQkTERERERHJISVhIiIiIiIiOaQkTEREREREJIeUhImIiIiIiOSQkjAREREREZEcUhImIiIiIt1aKIQ9/fdhx676YPT/XPH9fnt2dTwi7aUkTERERES6tdNOLBl26IEF+/TrGyr7wcX9vtzV8Yi0l5IwEREREenW3p+TqANIJFxy1epUVVfHI9Je4a4OQERERERkS956t7XuS2dW/uHIzxcO/cNdtXO7Oh6R9lISJiIiIiLd3jOzmquemdWsXjDpFbZ5OKKZDdjG/Q7c/nBERERERER6t2zmhL1tZodtaQcz+y7wYvtCEhERERER6b2yScL6AU+b2WVmZm1fMLO+ZvYP4HqgsiMDFBERERER6U2yScIOBj4GLiedjA0GMLOJwDvAscCDwH4dHaSIiIiIiEhvsc1JmHPuPeAA4G7gCOAdM7sVeAYYAFzknDvFOVfXGYGKiIiIiIj0BllVR3TONQPnmdl7wC+Bi4DVwFHOufc7IT4REREREZFeJevFms1sEvD9zNN60r1gPzCzoo4MTEREREREpDfKpkR9yMyuBf4JFAJnAGOBJ4GzgDfMbHynRCkiIiIiItJLZNMTNgv4AekiHPs75+5zzq12zk0FfgiMBv5tZt/qhDhFREREZAdmBgP6hyJdHYdIR8gmCZsA3Aoc4pyb1/YF59wvgMOA5cCvOi48EREREdnRlRRbaOF/Rl64/N1RP47Hhn2pq+MRaa9skrCvOOe+5ZxLbOpF59wrpMvTP9QhkYmIiIiIAFOOKho0cEB4gJlxxKEFB3R1PCLtlU2J+q0mV865Gufcye0LSURERERkvWdfal7V0Bg0plLOn/1B65yujkekvbIqUS8iIiIikmurq/zk6IMX3LrPHnl9Xn69pbqr4xFpr21Owszssm3c1TnnrtrOeEREREREPqO+wfkvvaYETHqHbHrCrtjCay7z1TLfKwkTERERERHZhGySsCM3s70MOAj4FvA48Pv2BiUiIiIiItJbbXMS5px7fgsvP2Jm9wOvAX9rd1QiIiIiIiK9VDYl6rfIOfcu8Ajw445qU0REREREpLfpsCQsYxGwVwe3KSIiIiIi0mt0dBL2OaC5g9sUERERERHpNbIpUb/TFtoYAXwNmAg80AFxiYiIiIiI9ErZVEdcyPpS9JtiwMfAJe0JSEREREREpDfLJgm7m00nYQFQTboy4iPOudaOCExERERERKQ3yqZE/bmdGIeIiIiIiMgOoaMLc4iIiIiIiMgWdIskzMxONrNbzGyWmdWZmTOzv2TZRn8zu8DMHjKzeWbWbGa1ZvaimX3VzLrFuYqIiIiIyI5ts8MRzeyZ7WzTOeeOzvI9/wvsCzQAS4DdtuO404DfAcuAZ0mvWTYIOAn4EzDVzKY557ZUXERERERERKRTbWlO2BHb2eb2JDnfIZ18zQMOJ51EZWsu8GXgcedcsHajmf2YdNGQr5BOyP6+HW2LiIiIiIh0iM0O0XPOedv5CGUbhHPuWefcx+3ppXLOPeOce7RtApbZvhz4febpEdvbvoiIiIiISEfYUeZJJTNfU5vbwcyuyMxF2+ojRzGLiIiIiEgv1OuTMDMLA2dnnv6rK2MRERERERHZYhJmZr6ZXbrRtn3M7OzNvacbuhbYC/inc25mVwcjIiIiIiI7tq31hFnm0daJwB2dE07HMrNvAd8DPgLO2tK+zrkrnHO2LY+cBC8iIiIiIr1Srx2OaGYXAzcBHwBHOufWdHFIIiIiIiIivTMJM7NvA7cA75FOwJZ3cUgiIiIiIiJAL0zCzGwG8CvgbdIJ2MouDklERERERGSdHpeEmVnEzHYzszGbeO1S0oU43gCOds6tznmAIiIiItLhvv/ffcfN+sfwE047sWRYV8ci0l7hbdjnBDMb2eb5eAAzu30z+zvn3FezCcLMTgBOyDwdnPl6iJndmfl+tXPuksz3w4APgU+BkW3aOAe4EvCBWcC3zD5TQ2Ohc+7OjTeKiIiISPc1fq+8kqt+2H9aJGLhA/bN3/3Bx+qv7eqYRNpjW5Kw8ZnHxs7dzP4OyCoJy7R/zkbbRmcekE64LmHLRmW+hoBvb2af54E7s4xNRERERLqRIOjqCETaZ2tJ2Hm5CMI5dwVwxTbuu5DPls3Pqg0RERER6Tnefq+1/ifXrI4dN7l4t9/fWfOG7+O6OiaR9thiEuacuytXgYiIiIiIbM4Nv6uZe8PvauZ2dRwiHaHHFeYQERERERHpyZSEiYiIiIiI5JCSMBERERERkRxSEiYiIiIiIpJDSsJERERERERySEmYiIiIiIhIDikJExERERERySElYSIiIiIiIjm02cWazezs7W3UOXf39r5XRERERESkN9tsEgbcCbg2z22j55uydh8lYSIiIiIiIpuwpSTsvE1sOwk4DngeeA5YDgwGjgQOA/4BPNSxIYqIiIiIiPQem03CnHN3tX1uZl8EpgDHO+ce3Wj3n5rZ8cADwO87PEoREREREZFeIpvCHD8BHtpEAgaAc+4R4GHg0o4ITEREREREpDfKJgnbF5i3lX3mAftsfzgiIiIiIiK9WzZJWIJ0IrYl+wLJ7Q9HRERERESkd8smCXsa+KKZXWxm1vYFS/smMBV4qiMDFBERERER6U2yScJ+CFQDNwEfm9mdZnadmd0JfAz8GliT2U9EREREpMMcP6Vo8N23Dpp41BcK+nd1LCLttaUS9Rtwzn1iZhOA3wLHAKM32iUOfMM5N78D4xMRERGRHdzwIeG8v/1hyPmhEKGTvlT8+fLd5/+yq2MSaY9tTsIAnHPzgElmNgzYDygFaoG3nHOVnRCfiIiIiOzgSvt4Ec/DC4XMi0AkP8+yGc0l0u1klYStlUm4lHSJiIiISKd7f06i4ZY/1zx+/JTi8XfdX/dKdW2Q6uqYRNpju5IwM9sN2B0ods7d07EhiYiIiIhs6JIrVr91yRWr3+rqOEQ6QlZduWY23sz+A7wPPAjc2ea1w82sycyO69gQRUREREREeo9tTsLMbBzwHLAr6QqJT2y0ywukqyOe3FHBiYiIiIiI9DbZ9IRdDkSBzznnvgu83vZF55wD/g0c1HHhiYiIiIiI9C7ZJGFHA//nnPtgC/ssBoa2LyQREREREZHeK5skrC+wZCv7GOneMhEREREREdmEbJKwFcDYreyzJ+neMBEREREREdmEbJKwZ4DjzGzXTb1oZgeRHrI4syMCExERERER6Y2yScKuAVLAC2Z2EZm5X2a2Z+b5o0A9cH2HRykiIiIiItJLbPNizc65OWb2FeA+4NbMZgNmZ77WACc55xZ1eJQiIiIiIiK9xDYnYQDOuX+Z2SjgHGAC0B+oBV4B7nDOren4EEVERERERHqPrJIwAOdcDenFmm/q+HBERERERER6t22eE2Zmh5nZgVvZZyczO6z9YYmIiIiIiPRO2RTmeA541cy2VHjjPODZdkUkIiIiIiLSi2WThAG0At8xs7+bWX5nBCQiIiIiItKbZZuE3QDcA5wIPGdm5R0fkoiIiIjIhq6c0W+vOS/vfO6VM/rt1dWxiLRXtklY0jl3LnAFcDDwyuYWbxYRERER6QgjhoXzZ3yz3wljR0V3nnFxvxNGDAtrRJb0aNkmYQA4564EzgKGAS+b2REdGZSIiIiIyFpNTYHv+/h+4Jwf4Dc1BX5XxyTSHlmXqF/LOXevmS0BHgL+ZWYXdlxYIiIiIiJpVdVBctoFy/582gklu973cP2cquog2dUxibTHdidhAM65583sUOBx4A5gfodEJSIiIiLSxuPxxpWPxxtXdnUcIh1hu4YjtuWc+wj4HPAaMKbdEYmIiIiIiPRi2fSEHQks3NQLzrnVmXlh/wMUtD8sERERERGR3mmbkzDn3PNbeb0V+EW7IxIREREREenF2j0cUURERERERLbdZnvCzOwZwAHnOOeWZJ5vC+ecOzqbIMzsZOBwYDywL1AC3OucO7Mr2hEREREREeksWxqOeATpJKywzfNt4bYjjv8lnTQ1AEuA3bajjY5sR0REREREpFNsNglzznlbet7BvkM6aZpHuifr2S5uR0REREREpFO0a52wjuKcW5csmVmXtyMiIiIiItJZVJhDREREREQkh7ZUmOOw7W3UOffC9r63q5jZFcDlXR2HiIiIiIj0blsajvgc21dkAyC0ne8TERERERHp1baUhF3J9idhIiIiIiIdprSPF558ZOHAZ15sXrW6yk92dTwi7bGl6ohX5DCOLpc53yu2ZV8zU3IqIiIikiOhEPbucztfUN4/1K++MWgYdeCC33R1TCLt0S2qI4qIiIiIbE55/1BkyKDQQM8zK/W8PnvvnlfS1TGJtIeqI4qIiIhIt7Z8pZ944ZXmN4PAuXc+aJ3z6pstNV0dk0h7ZNUTZunFt04GJgPDgLxN7Oacc0d3QGybiyECjAGSzrlPOus4IiIiItJ9HP2VyseAx7o6DpGOsM1JmJnlAf8EjgCMdNGOtisiuzbbs2JmJwAnZJ4Oznw9xMzuzHy/2jl3Seb7YcCHwKfAyHa0IyIiIiIiknPZ9ITNAI4ErgJuAlaTLmRxG+nE7FrgZeCs7YhjPHDORttGZx6QTri2JXnqqHZEREREREQ6RTZzwqYBbzrnLnfOrVm70Tm33Dn3N+Ao4Fjg29kG4Zy7wjlnW3iMbLPvwo23bU87IiIiIiIiXSGbJGwM8FKb5w6IrHvi3HzgceDcDolMRERERESkF8omCUsCLW2e1wPlG+3zKeuH/omIiIiIiMhGsknClpAuirHWXOCQjfbZD1iDiIiIiIiIbFI2SdhLwKFtnj8M7G1mfzKzL5nZL4FjgOc6MD4REREREZFeJZvqiH8FRpjZSOfcQuDXwPHA+cB5pMvTzwN+2NFBioiIiIiI9BbbnIQ5556jTS+Xc67JzD5POhEbCywEHnXONXVsiCIiIiIiIr1HNj1hn+GcSwF/76BYREREREQ26earyw84/aSSL7z4avN7J5637KmujkekPdqVhImIiIiIdLaCfPMuOrf0S55nNuWoos8ddkjBm10dk0h7ZJ2Emdk+wL7AcNqsE9aGc85d1d7AREREREQAWlpdUFsX1BUVWmHgCOZ/mtT0F+nRtjkJM7N+wD3AlLWbNrOrA5SEiYiIiEiHcA4mfHHxbeed1mfsozMbFy2uTLVs/V0i3Vc2PWG/BqYCTwF/ASqBVGcEJSIiIiLS1rwFyaaf/LxqdlfHIdIRsknCjgVeds5N6qxgREREREQ2VlRooZceG3HK6J0jw39zR83MH/1MyZj0bNks1hwCXu6sQERERERENuXcU/vsPG5MZGRRoVd48fllU7s6HpH2yiYJexMY3VmBiIiIiIhsymtvtlSB0ZoIEp8uTlZ2dTwi7ZXNcMSrgH+a2UTn3IudFZCIiIiISFuvv91ae8QJi3976EEF5X/+a+2Cro5HpL22OQlzzj1jZqcCD5nZY6R7xmo3s+/dHRSfiIiIiHQjZnDz1eUH7rlbdMil11a9+NJrLdW5OO6ZJ/fZ5exT+hx+wtSij48+ufLRXBxTpLNkU6I+ChwP9AXOyTzcxrtltikJExEREemF/uvs0lFfO6t0cjhE+P7bhgwbPn7B73Nx3K+fUzo1FDLvcwcU7HVsRdFruTimSGfJZjjiNaQTrw+A+4GlqES9iIiIyA5l/F7R8nAofQ3Zt9Qry9VxV6zyV/Xv5/V1Ae79OYm6XB1XpDNkk4SdCrwLHOScS3RSPCIiIiLSja1Y5Tf5vvPDYS9U1+DX5+q4B01edPt5p/UZ/dTzTcvmLUg25eq4Ip0hm+qIZcCTSsBEREREdlx/idXN9wMC5xxzP0ksztVxl6/0E9fcVP3R62+3brImgUhPkk0S9iEwpLMCEREREZHu7xvn990tGrGImXHIQQXjc3XcwQND0csv6bfnYRMK+uXqmCKdJZvhiDcAfzSzcc65uZ0VkIiIiIh0X4uXJtcNQQwC/Fwd95V/jjhnYHm4fMY3cROmLro1V8cV6QzZJGGVwL+AV83sJuANNl+i/oUOiE1EREREupkbf1/z8VETC18Zv1fe6GtuWjMzV8cdVB4uj0Ytkki45D575JXm6rginSGbJOw50uXnDbiMz5anbyvUjphEREREpJtyDj5ZmFw9bHC4X219kMzVcW/8Q/WjXz+79Jj3PkrMv++h+sp7cnVgkU6QTRJ2JVtOvERERESkl/vi0YUD/+vs0qnhsIV+/8uBI++J1V+Ti+Pe8qeaOc7Bi682L/f9nnlNGgphj9xffuweu0fG/Pmuhqeu/kXde10dk3SNbU7CnHNXdGIcIiIiItIDDBkcLgiF0qOe8qIWNcvNcWf9Y8SZw4eEB3/v6305ZtqS3+XmqB3rpOMLh5XvV7bf6y197NT/qj5eSVj7jLrlBm+3W1aGgIIn5l5XN3XcDAPsibnXBV0d29ZscxJmZpcBC5xz6v0VERHZyNTh39oPuA9YDpz0xJKb13RxSL3CI/PHHwUcnGy2u/+wz7iauH9/U0Vouq345oQL/DxuBpIYx7x/7Xde21I7ZnDeaX12rqkNEv/3eMOy3ETfOy1ekmwEcM7hwOUqCRtUHhoQjVqkNeESe+2Wl7NForfXmBtu7F/47prGwfd8fC7QF7j5S3f23+t704+wvDeqCYbsHg7bIk3h2U6jbrn+9j4ftZznMtOlpo6bsRKIAMVTx82Y/sTc6x7q4hC3KJvhiP8L/LqzAhEREenJglTynqC6dlfMdiUvem2FN60vJUUNFBdeEq/8bVVXx9cTPTJ//B7Vqwsfm/3I4Oj8u/hpy7CiyFHl567yyorLHS596W+Wj+P7wLQttXXHTYM+P/34ksMxuOzaqgd/+dtqVXrOmFxwVj7wXxQVftFFwqNdMvHreTeNXgj4wMwFZ/xog6F/jc3ODwKCUMg8FziKCi0nicTVv17zyPcu6jv5o48Tn95+X+3C39+Vi6Nun7E//+WPBv5t3s+K36/x8DwoyIfGxh831+5WmD+nFTdmOA2jE+x94IXfP2Da/1z3Ruymhq6OuScZddsv+oZWJ88b8mQtZt7a2wAD2+zyO6DXJGGVQJ/OCkRERKSnmlR41kTneXuuu9iqqf0au46ERctg2apzjy4+jQHn8uf+54f+9Nv9//JKV8fbU7w8c+TENy/rV0BVPfX7l4f6zGmCZHLg6opy8j5aQVFVQHhlE82DokGFNy0vHsRaN9fWIQfm7xKNWsQ5x8TP5e/8y9+iJAyYMPnS7xb1yf+FV9ccor4ekkmqv1h+a59Zy+kXW+mSA6KzKs6admQ8iK0b3rV8pd9ihgE4cNGIZbPu7Ha77pbqOdfdUj0nF8dqj8l9zhtYMmXIz4vfW0O6np2DhgaA4idjOxMeUkrtmGYa9ytl6O8q87zWoG5ywVknzGy+5x9dG3nPMCl6+j477Rm5ITy7GUaP3Nxug3IY0nbJ5n+ah4BjzKygs4IR6ekig/oWDPrmSRP7nviF3bo6FpHNOevVC+ysVy8ofHT+PpFH5+9zwKPz9ynp6ph6qgpv2viK0ClvO9+fFaRaobgQajKrt8xZCM2t1B41hvJvGYmTSr+6rK7kpQv/c/bkLg26h5gUObX4pZmjb6UqvSSVNfu4xkZcOETJrKWE8wKibywklWyica9+p6z+ym51e373l5v9XR44INTPuXSHztjRkcG5OYvu7bCxX3+v8O3lN3hr6kL4PiTThQ5TO0UYcNtS6g7eyWoPGHBYqn9+6sgBZz04Of8MAzhqYv7AtUmYZ3j9+4ayuanfawXLx4155g8HvhK0ti4vfWPtaGQH/vql1Bqihbhlq7FwPsN+uZBQc4CFI0Z6PV7ZgorQ9KFHF5z+a5dKvhOtSh2Tk8y/E2XzP83lwBeAh83se845TSQU2chO/3vO6cWf9BnudiHwj2n5S91Try/o6ph6mskFZxkwHegP/BlIAOXAqpnN93T7ibbd3XFHnTG6+rBRc0O/WRyad00fnvvpzrTUhPlt3lm3fDxjlyWp8rx9gGsWnjvj/a6OtTur8Kb1dXmR32DeaeYCCIL0hVZ9OmFwnmFB+oI/XNVM9R6ltJzfgj+m3KtewT+PXnrOl55ec9e/uvIcurNxV//qvOgFe143fN7SyNrL18iqZgBcyCM1KEr+ghooKSY5ZiAD75wNnhcNSgvX7Fd11ezmUUVPYnblR5d/p3ltm+HQ+muekJebnpvuqMKbFm4Z3mdm/pK6I9hjiOfNz0yPK8yHVAqAfn+vIzGyjFBjE4OfqYJk0vC8rwSwZFL+GeNue6lfRds2j5tcNCznJ9INvfhW6WvXfGtsP0Ihwgs2PQK55JWV0OxT8koIy88jSCRIluXhFfUde8ywixaFGhNnz6z583Nr999tbKSo4oiiwfc9VL9odZWfs+UAuiUXfOzKSgpZUQvNll4rYQt75yqs7ZVNEvYOEAX2B94xsxZgJZ89SeecG9NB8cl2+vJX+u80ZuKIXR+7bc4rH3/YXL/1d0g2pgy4sL9LpVLJwtCkkG+TvJbUVwz+WX5U+fDix+eA73tFe+1+7L95/ZaujrWn8Xbxvl1XVHhN3cElkb7/WHFZ/jLfyz/A6x/+UUFwyvMXvlftiibGj/iVxs5nqcKb5pGff27oqOifC66cQ1Ccx3PXDKdppYNkE02Dir7pl0bAOSxwn590yFXjnvz3pTv2B/5m7H/Rr0JlhdGXvT4lu9ny9RdaDmDtbQLPgyCdPhS+s5Tk78pIHDSU4r/PBfAcPFHhTftdPIj9d47D79aOnHRdqa2uLSkf2/THwgcrQ3sen2J25lIl0pLex5paiFTn4fVNQLSYwlc/Tb9QUkzNcbuEUyVu//yFDeNbdipOAZeubbslQWthoRU453j7/ZaFOT61bsMvz38+b0ndoWBE56/GGZgDEutHcpqFyc9Lkf/KSkgFYB6tY/oRHjtgqBse1LckX1+V8o3n3hxN/9JGXn97SU7mPE45qrD8yh/0P2L2h61Lvvbdlf/OxTG3VYU3bWxk2Kh+RMLpmzKbEWpM4QxcfSOuoAjXmCDSmMKrXkMQBCMC556dVHr++FB5//D4kfvu+sLMhuMjEcIzLu5bPXz8gh5ZEbI9Jpecu7PfmnjPUqkiwLz6RPqFNYl1+zjnMLN1XzNytoj49somCfOAJLBoo+0b18TJUY0c2ZwDD+0zoGrv/zqv8X7YafdjDikc1rrksEN/fHTee5W309C0AngiHsS6/R2C7mry4Iu+FgTB7wL8UKp/GeFF1QQNTUSL/DMKn0tCygczCt9t6tfVsfYkk4vP2X2X7zc+FkRKRicHFTH4lgVgNtDl51H8vxGW/60gFHpixb6hgvqPJ1Wfe/iTdXdqPsc2qPCmlRIKvQuMIC9KZOf0TPuCwlaaFtq6Qemp4WGG3rOS/JUhvL4lIx1WM+mQqw5/8t+X/qcr4++OvNqmG0I+u7G6Zv1G38e1KU1gqfXDjwzg3SaitSs32Gbh8EWTi895embDXX/v9KB7gG986+KpoeV5j9p7i0J7H+TzCSGWfhRh7b1ea8ncE/B9IlUt0BDCJWpxgcPMw+9TQGhVHUMfr8IiES+IrLp46u3f+ukTS25OAeRFyVt7rHGjozvccMQKb1oZsNKb2jdiT7QADgscft8ivDWN6c+ujGRZHnlLG8HPXCq4gMRBAwh9sojwzGZ7c0y/gQ97e/L062NxQHE5Y3NxDnfePGj6gH6h/nvvnrfLa40VQi8AACAASURBVG+2dKsKl4kx5VexcDX46bsFm7sYdqSTXmv1wTWnN9TVE3geBC7dG1lU9LZzLnXIrvtTWPBi2AwGD7SB+flZTSPqcSZ+Lr/v6J0jxffE6hev7eQK/NSfLEgVg8MBXroiZ7oXzAx/waeEdh6B8zxnZj6wGrjzibnX/ajLTmQbbfM/pnNupHNu1LY8OjNg2bqBY0ePLHgwhXt7AWtcnpX/e82IvFc+nugamm7H7CHM/lURmt63q+PsiSqip18QuOAP1NSGErsOJu/9xbiWVgh5hPIDvNoWKEhPmzTP48DQMV/u4pB7hElDv2FEwu9YqTfaXxSm9LHMvZ5wCPr3pe53eYTuqcRaC/CXBINda2JOReGZ13Vt1D2D37/wcXx/BACJVlKz0p2Iydog/SG2dq7CiDzy/7McCxv29hx444NCt2z11RWh6b36Qz9bFeHpo/NenP8/tCY2uGgFCIVCG8z9aCvZr4Dowtp1zy0vDysqgkjkb1NKz/9SpwbdQ9Q3h+6zOUtDAC190xnt6nkeeeX5wPrENn0BFkBrCgtcpjpEgCvOp/it1eCFcC2tWENrmQuC49e2H7h0P6WZMWrnyPAcnlqXmxQ51QN7ALOIe795/Qt+QKi6aePd6yOLq+qpT0J0/Z2FvBVrsLdaIHA8cvNQPl1eSktziCAFn5/Qb3wuziOZJOUcDoOmZpfKxTG3RUXe6cO9ZWtOtbI2qVc02naXZuAlYOS77pXbVrPiFQOfZCr9+2sGiWQ6AQuHIRIh8P1w/aog7HAELsDhOHCf/NJcnlcunXJ88dB4bPhFf/jloLMeuWtoBcBRo795F4E7hiCdcBkQNLesf5NzEATOX7hokJl9ARj3xNzrhvSEBAyyK8wh3djUcTNCU8fNmDCp/MKYHx/7Jd6fT8u4AZS9uQaa0kMMzPPAEcUxyfLyPpky4n+O7OKwu4VtWd+kYuLVkYohF/2RvMgfqWs0gGDt5PtkEiJhGhvy07e+EgnAIAgoC8r2qwhN142JLZi83+Xm8qOvBq2JyJybQlhVTfpuIIAXgsYmWh9bBYBrbcUrKYKiQhID838w6sZfrB75mxsqR/7mhpxcAPQkFaHpduxx5zwXqmr6/LqNrUlS76WHyQStHqybFmNEZ4dxxQW4VWtwiWS6Z2fR0kk4N6ciPF29uhlB/75v5y2pW7+hzR8QS/jpcTHQAqwCngMmg9V4GCTaDECIRvGbm1h2Zp/wguvHPLbrn38+Z9e//qw4N2fR/VR4005f9mRDKcn0dfWCv2euNX2f1qpEengn3IHZGjOrBVI41ww8Z5lBoN6qGoLAJ6itJaipIairI6iuuWRKn/PCAJXLUsudczjnaG11m62i2BulykueB1eBc3iLWtbPI/EDLN3lkAL+APSJB7E+Tzfe1wc4gtbUup9Tqq6QUCIgMjCEFfg0tLaQ/9RsQo+8w7uPRXLyuxt/vvEdDFpagpZZrzSvzsUxt6Yi/8yJJJOLQwnjew+3KZeQaMUikTqvoOBGr6BgQDyITYwHsU9XsmTZ227WzGfdQz9fGVS+CKyf25SprupqanGVy4k015AgSYIUCVJ87oC8/l1wijlx2ISCYWZYNGqR8XtFR+81/swTrK75bPxgfc8Xn+lhfAAoi/sPrHxi7nUvPTH3uh41D3+7kzAzKzGzEWamsvXdwwN+KvVCUFx4sleSvvuSV9WKV5OZyFxUkL6wDXlQUoxLJvv6S5c/U1F8zgNdGXRXe/rvw45NVI697K2ndzo1FNr06IEKb9quLKlcxsqqC9r2HEQXrx+KFETC4EHr2ELwg/RdWrP0HS3P5k2KnJqfmzPqeYJPPj2ChUsOoqUFV7vRP0FrAprbXCslEgQtrbjaelacMpJwC/3zqvyhwA9yGnQP4Mzdt9MeDYev22C2hXkKjiDw0vlDzfq74un7jm4sQbCiIjx9ZKcG3ANUeNO+5w8pLdngt9S5TDJrAC8D3wBK4kFsYDyIHRkPYk8CY8IrGnzW3bc3nO+z/PwRpPbsR1CdT1CVNy5U692Ry/PpLqYM/PqZwF9ok9yGKxvXJQouCCAI6sH9d9x/oD9YX8zbCfNK40HsSKAEcLamHq+qDhIJLBKBSATn+xP8ROJegJ2GRdYVjygr9Xptj8LGjhl20Rdtdd3Etts2+kv7L6AsHsS+Hg9ibeeQvwDcBLwGVPol6dGcx3y3ir4HRVkeC8AP2PukZg45bFmfRZ8MH9KZ5wHw5cnFn/PMLD/P8r96RmlOhkBuyaSDrywk0fq8I/0z/dsfJnDyn5YRLgoAFrtkct+ZjXd/b2bj3Z/pbgzwg9m8/PQcZv+VVGbcZxCke8RwEATUr3YkAnjgzbE8+e4IDtg/2mt7cH97R80HiYRL+L4L7n+k5Y2Bi8P7WmsrBMFGv6/rnn0hHsSmx4NY3Wca6yGyKilqZmHgEuACYFSb7QuAPwHXO9d9uod3MJNc5bIIQwaQXB4FEoSaUvhhIwRYY2b4ge9nHin8whCrvjpw2q7XX/Z+clh+xfzTfry0K08g14Ll44oOP6TgADNjj3HRsRMOyC976bWW6s/sGA7dT8Pq/kSj64cLAKxdGzAUwnwfa0piNZH09rUJbxDg8qOey4/OO3LydSOenTlDc/HaqPCmmSuIxtf9SU2EwMsM5woCwEEyBXketGYSiESC5r0H0n+2T35tE6HqRlr7hvfjG11wAt1URfiU/w4Ko9P9hXWwbhpMZq2a9PcO3EJccBGhcAI/Fcqbt+IhP+UXm3OZohKZn3+6pydMEFwKfDX3Z9P1jjr4sqH25kefGOSHFq/EIiFIthl26ILHgR/Fg9i7m3p/PHhgTYU37QLgesAD15emJkJNEGp29L97IeHl9TSeMvCYnJxQNzJ10EUjgD8CRp9iqE0Pl/USAUF+BOcCzHdL4on7R6x9T9y/3wHr5gPFg1hThTftBAuCm/0hZTuHltXgzKClBYry8fqUnjJl6MU1D79K+KevH8w/Y2PoP7wl7OXf2uvLqleEphemRpT/I5LK3BjcsJpcEhgVD2KVm3pvZu74DEjPLS14Z+niAErqayKc8l8f8fOH92XCr5v44fHvkmceVYnoh0BZZ57P62+3fHTE5wv3dw4389nGyku3/pZOM+ngK49xcxc8QaZDwwU+lf+X4v/+tRdBqr4uHty707a0s9jN/XhX2+eHwLWEQrbuGsMF1FTl8d07Dqfypig4x9iz++1+WmedUBc75fiSkZGwReqqQ96Tfzp2KmtqcGXFmGtp85kEmV/iveNBrMdX8N3mnjAziwJPAlcDI4HFpO+OLM48vxp4KrOf5MjUcTMOmTpuRhVQTDKJNbRAY+aGS0sCrymx4RsiYciMp63+0iCSA8rx6kr2sAb329xG3i00LVmaWppMBqmmlqD53Q9bP3M3paLs/Gux0L6saTN3Ji8CQLg589zWJ7nRVU2su0tTkE9QVkQwrBxLBsO8Dz59udPPqAep8KaVAgkXBOsnHST89B/acJtrIz+VvlRowxUVEl3VjPfep7i5C4m+Om+3ioIzvpebyLu3ivD02wjcb7wIzH+oML3R89K9s2k+uAnxIDY6HsRmxpP3PRsPYk9Zwi8LRSMPEAChEGt/j/2dBpP43K4kDtntvEknXb5DziW1uZ9+6gUu3wCvugFLbjDv6/V4EDt2cwnYWvEgdmc8iA0gvdwCAAMfXUzZLYvI/3AF4boEfe9dXTap+Jwfd85ZdFutftWa9HXD/m1qZQQBXsIPQike9Cw0bmuNxIPYP+JBbGRq18EfApBI4IpCMHwIzcMKaS71Lpz1TlHVs5eX0ff+jwluXMy+E6dUbKXZHm1y0dnH44J6Aj/9N9YMIpG2u5y0uQRsY/EgVhuuqh9AyIuvmB2hbqFHcf9m9jugmkXVUa67b3dm/mNk6ZRBF+3eCaeyzhdPX/qvk7+67E/7HLnopk3eNM2Rw/b+arFftXomdQ1hyPy1LMjDBT5+TQ20JnbJssm/AosInFt3reF54ByL/ppHUF1PUF3H3HuKe+1wxGUr/KbKxV7o1H32xi2t8SxkWEPmejbI3EQwi5MeadDjEzDIbjjid4EjgMeB3TOFOg5xzo0EdgUeJb2O2Hc7OkjZtKnjZhjwPJCer2GGa2zC8vOhf19obcVC4Q3XEEj56y7GPIoZ/vuFDL2vklHfnXP8McVn35zrc+hK3uC57vXZTZ+stNZwVV6y+J7byie1fX1S9PQymppnYI4gZOkesFQKyvulk4R0ZZ4WAnct2LVr3+eCzLCC+kYoLiS0YBnUN+BVrppQ4Z3S7Uum5sLk8guHkJ4zE3aRNiXlAj89tCuZxMLhl72Cgl0wz8NxImbXAEsBvNpmbO4iaMwUmRhcQmpU/+sP3/fbv8r92XQfFd60fYKivK8BWE0i3fHleZlSfOnyBaQrR83Z+L1x/34/HIqcbtHoSy6ZHg7jykoIyospWr6A/S79yPa4+MM133nmlBOnDrro8KmDLur1CdmkyKmHTIqc+hJ1TZ/tMVk/F+yn2bQZD2I+8DcAGlOEP61J/y0JhwgaGnAtLVdPLjv/iqmD/ztvyy31fJMip5pf3/A0znkAqcUtpPYeThD2cLCCIJj4ZPJv055s/Wvz1tpayx9SNsGFvWowSr/g0ZzXSN5/FpA/fxnzF5UOyntvdfpzMOlT8lYo2wvlHqPCm7Z70Nz8IOCFl2dylSDAzPAKC/EKCy+OB7HHsmkzHsQSTyfvn/TJM3mn3nXJaPaaUMXsWcOYceMRzLq6D/deMQaXSHwwecCF3+yEUwKgsMBCB+yTN2C/vfM6tcdtSypC00P+2OKVXmXVBtfQ1tgCLa1Yyp8TD2IrN/f+TYkHsSXxIDYSF+wF1go4nCN/SAi3pBECHysowGuNhiaXfXW/Dj2hbmL//cODv3HiPut/pjsPxVJthtA714xzk+NBrLELwusU2SRhpwPvASc45z5u+4Jz7hPgJOB94IyOC0+24gBg/W0t57BEApdMEiothfL+uESr75W1mba3dqgRUPrCKlxRHt4nS7HGZqyp+ZsV3ik7TJWuYPk42/uo0ok3r57Ab1YfQmi/4Qeufa0idEpfB9WkUuD7+H0LcaSvYF3lSigraWJI+fVx/4GCeOr+H2F2D+Y1BeDXU/NhDWveA/Cq6tcPXwTATarwpu3Q88MqvGnRIJlaTOZ312toM+crCMAFDudefjJx3+dnNt49L+7f7+L+/Q/H/Qd+HA9iw8D29ZKBI1OuOggbkSbHsCOWs+8NS7990cOn3d4V59VNvLUuOVg7fzEIAAPn/gkcBIyLB7HaTb35X3V3+PGWv0w0OAVwLhLBW7iKkoMTfHBWCe9PMj6cVvp/zrlnnXMfTR10UUmuTizXKkLTIy4Inna+f+gmPyjTw7oWkJ5Pk60zMJtGcZigPJpO6FoTYEaoX18smne5S/979WoucJcHJfl7rX0enreE0EfLMd9hsG88iGW9DtQr936vzlLBCeACCzyi76eL+ky+dRkjJvqYHxAMLyR1xnC8oWVddiGfA/8iM+XE/PUXsi6RIGhq+vfMhrt+s70Nz2x64P75a1a/+OLf+zW+XjuYnes/xQ/yCaprCWrrCNZU31ThTTt+6y1lLx4bdvwPv9X3hLtvHXze6SeVdM38KBfM9pKJApKbXEbxV8Ch29t0PIh9AG4EcDCe1zzmxEa8xiQWjZI8o5jm6waSOK+w142qOeawq0M77TXic36bUiu2ZCUUFpC5i9gCNqW3La+UTRI2FnjCObfJmd2Z7U8AWqg5dw7f4FlJMeaFIHD4SypJNtetfD718LXx6tt/CkwCPgB+QxCsAfBWVWNLV7PhettuR+oNK/w4UWYp5+Hj8U7rEA+gwjtlKs5VpZMnAweR1Y04z9JDD507O77ytqJ45W+/v7ahuH//B8Bec9ybf3ndPf3gXPf2U8C6oZ8OaDpyT1qnHEjzpPGrjphy3Q5ZmbQiPD0ELKKufl3310YTxJPA5cBmP8DjwQOz81c0H2eZERuJkYWErIHmffrwwUlhPjnLnXfC/tOndkL43VZF6JQhFaFTagDPq99Ep4HvVwGnxIPYG9syiTkexGJAntfQRGh1LUtXD8JV1WfmOoaw9GqY5cA2zXnooY7AuS31Rjng1EzPVlbiQSyI+w88SD3f8VYl0gmdC9LDQAvzYXB/6Fd65JR9Ly3c/vA7lxlcf8WA8ff+dtBhpX28rOZWTelznlXkn3E9Lrg8UbRRu8kU5pyLB7EV2xtbPIi9AFzdWOW5tetcfTh4FENDTQQe1J2/K6sGDaP6i+Ns0i/+t1OHz+Xa0WVnj6zIO6OJtv9vOte25/ZeYOIm3pqVd4IXn37OPXR9ScOSyrfLds1Mg1g359TAHq7wThnZ3uNsbNex0Z3zol4kEiZ89GGFI7b+jo5T4U3rc3TktCpgj/zKZghHNt7l7HgQ+248iK1pz3HiQWxVPIj9x6LR0XNe68fAMQ24Ig+3rB95P2sg/Ps1+ceUnbvi4HNv/MnB59543cHn3tijC+RNKT3/+yxctqh2nq0vluN56Tn4Tc1k/kAOjwcPvNB1UXaObC4EE8DWSpAW8ZnZG9KJNpifGRpYjouEsfR8Dn9505xXUkFLCiAexOLxILZnPIhdTPri6V4/4mGZcsAUFEDIw/LzR08qOPP0HJ9HVwnlBz4vLRzNzDm7U786lB7bhnuccNhY2/eVmcjsBQ5zPEH6Q+wz4v79CyqZv9DhXB1ralexdJbLTCQNCqNEVzUTffMT8l77pJiFS7+WixPsbtyA4kpg0GZebgGGxYPYVfEgtsXSw0/W3vG4B98HCNclSSWMqmvBaw5w+cU0RHf/+zGH//w3xxz+8x0j2XXuUyKR0sz3G796D7B/tkM44kEsSXPLzwCChWvf6giamnC+j0skDPiwfYF3Yy4YQ+Yz0i9a33md+ekmgZ3jQey19hwi3vrXX3uOIzbovSwuwvol6XtJjfX7yYq7T3vlwm75O3z3rYO+8O0Ly46ffkLJka8/OeKsbX3flL1/UuLjXiCR+B5AtLKBjX5jHXBUe+OLB7HLUm83HxQKWQCw6OcpRvVZQ/S4YsLv+Qx7830m9HuNsuYVvWa9wUOPuexsrymxgGSi4DMvpv8uTI4HsTPjQWxzZVKz9tZ9Vf9JBpENRnxYOJy+oeB5127hrdslmUwXf3MuPVwvVyq8aZHmsQMWeeFQevrH3FS6vlF+HoTCEI78Jh7E7unIYz7ZePfyeW+880jl4KEu1ZIi8loVLFsJrQlah5YMxA+uAr4N3NCRx82lKaXn7+0nEle6sA0NDW1zz2t9JV8HXBYPYlVdEF6ny+aP+2zgZDMr39SLZjYAOBl4pyMCk22ywd0PMyM8fCip8pLq2clZf5qTeuOtTb0pHsSCeBA7M9Qa/Hvdp19LK15+AS6ZxKVS91bknX5wp0ffxbzBc+sW1g6hvrKYyAd5PPHJvvmf9477KmAb/HFf//2IeBD74rZ+gL3jXn5miZv3GBjWkiS0shpbWY1XU09k7tLfV3jTevNQmM849OKrPmcr69IJ2GcXZ0uS7qlZta3txYPY9YRCM8MrE5A0ojUunTbvOhLyogU4dwEb9xb3MlMGXOhVFJ55ARBh40vZtMnxIHZ2PIgt2p7240HsUnBPherbDqk1XDKFhSM4P3h/avnXP3M7uCebXHR2WUXe6ccCv1u7LTVu8LrhyBlj4kFscUccLx7Ense59M1L3yeob6D8h8upn1VE3cN9vhKtDLploY4D980bBenPneGDw4O3tj/AodNv2CUZdstpaFzXE2NrF6td78Z4EHuuI2KMJ2NvmBfeCXDBWymWJgOG7+QofOEjrvrDM5y4x/t8+7inj7vu5SkDOuJ4XakiNN2iH6+4deMFxNuYmVkuoUN9snLWu2XNVesqVVokivNTpAZGaJo0aPqBX79i34483oOPNryS8p2fSLrEvf9XP7cj296cSdHTQ8AZ4RX1pbRmhs83t0JBPvTtA3mR++KJv17cGceeH7w3u3HWJ+8wqIRUQZsOZzMiS+ut8N+fRryqhh673ILf0jKe1tZ8quv44I0y+u29/rXABX48iHnxIPazrouwc2WThN1KugflNTP7qpmNNrMCMxtlZucBr2Zev7UzApVNunuj5/XADbMq7/ztymDx8q29+akgdihrh5caBI2N60vYJ5OvVHjTuuUd2I6UTIbp+3yUPu8bg29bEi5weekx5v5nPsiOjgexJdm2P4e33/Dy8gpcQRQLgEimeKjngeftMEPmKrxpOxU8//GL6zbkbTDKa3k8iEXjQezRbNv1QqFjgbf8snxcXR1WVAiJFF5jK5bwo8A2Vf7qqfzm5odoaf0jkB66EQq1ffnCDrnoMu/HkZqWdfmHa27GeSH82jr8urrd/IaGX0zOP6NXrF0zpfzrBwSBX0UyucHvYt4na3A7Dcb6FOMVFBzVUQlYG+nPzUgEV7mcVZf3JxFP0Pp4Fct+kNeVVbg366OPk+v+32pqcdtUOCO8quEGb/bHWxpi+T7w8/bG1taTrX+tBL5AAt6eO4LdDlpGhBZ+dvYRXPXNQ7l0wkH8+6t9HurIY3aFhl37fOCq6jc3R9MBX+6M4/pB0n/piXvv4KBSH9JruvnFHq1jBlL4/BpK7/3k7aOj0w/pqOP96d66j977sPXjWa80v/3qGy01W39H+0wa9PULnO+3AneEGlrZYAB9bT0sWwVNzZ1WiCTAD/7Dc494axLNfr/1PfL5K1sofO4jIvOWW8k/359WEZre5WumZasiNL0PyeRdAF5rwAtXFjN0Qit7nNxIC03L3+bF33d1jJ1tmy+ynXMPANcCOwO3AR8DDcA80muEjQJ+mdlPcuMDoG2vTMUTc6+7JOVatn2ttsD9iPRQ0w2k+hVZ04RRbx54wY27tT/M7qt/ssnlLVzNkKbZ+B+kNirfa2sfn48HsWe29xgzm+9pCTW2NvmpJCQT6cqKQQDO/bXCm9b716nxTjkQs4Xe/NT6c21tTScMZs3Ads/JmNlybyoexPb36lo+AnDRMN6yKty7c/A+qSQ8f/lPp478ziYX4e5Jpo6bUTR13Iw/TB0347K12ypCpzxHc0vmwipzikGQWTiYT+NB7I8dcey4f//rXtKtL5DgHK62Zl2lNYLg28651ybnn9Gjf85Tx83ID5x7gdbEZz8X6+rwKldBU8uJTzbe/WxHHzsexL4LjLJoNCAI8CsTuGXLob4Bt2BltMKb1u3uBM/+sHU5gHOOVGrr64NOyjs9mvef+cdtusM23WQ8iO3V3vk0mxIPYi8Bi/905WG899oupBryWB7pT/6ntXgpR8McN7HCm9Yjl9eZnH+GHVl+7i+LP6rZLdy8ydkgDtg1HsQ+8znfURqqE8nn3r795+T7MfwUyaP6UfTyYmhuwWtswfN5ucKb9qOOONadNw86du898nY94tDCA675yYBOrRI4qfCse11N7R+B9N0tl/mPt24Jj/eAaC6Gyr3f8Ow94ao29zocmXmka6vf8nhnx9CRJkVPP9G5oBYvveCqZRZkfu+PeXzwYBGfuPf/uYaVW5yW0Btk1dPhnPsx6aovtwNvAfMzX28HPu+c+2G2AZjZyWZ2i5nNMrM6M3Nm9pds28m0NdzMbjezpWbWamYLzezXZtZbSyk/TPqu4ZvAeU/Mve7VbBuI+/f/AjivzfhbgmiY+i/vTevug/YlcO8eeMGNvWq4UVuvLMhfFZm7kugu6xYBbPOqA9zcePBAR1Qi2stLpNI9YOsWYnQAr3dA291W5sLmJRxG2wuEdOW+FM6VxoNYu+9meongZAAam3GVywn160/Q3Iy/qupUv6n5tva23w18BFwI/HTSsIs/mFRw5iKcazPUMvN7my7w0AiM7uDjf5l0b82fsczB1naip4eWDiLLz5Nu6EeusXHzvTS+/8V44r6HO+vg8SC28P/ZO+/4OKpr8X/PzO6qWZZ7wRhsioFQQ++h7dr+AaHFyIgaQjAJISEJCUkICSTh8ZxGSF4KJQklGMtLeIHkxVhLC4TeCdXG2Bjj3mS11e7OPb8/ZlZaySvLsqXVyr7fz2c8npk7M2dmr+7cc+8pqP4GQBs6uu9pZcV10bFX/HbyoTcUjaJ74ecqjwT/9x8+NPCT2QyayaymsXmTSDwBVyZMvFfN1vJwDs9/oEvurodKWiteWOrXXUeQcBgpLV0/ueKiVydXXLRTH8vRqxiYZVqT1wBIONx5Nhzg2ISJL9j0zN4lk1JD0q0G1PlPst2nxw1l24r/ioaqNRqq/jAWnr7VM+djRrrDHUFCIUIHH1DSZ4E5Jo+9cqgRakhnctL6BBgP0FbgoISJFyQOwkpvyfKFSxL3t/VQHPy8r8Ygo0bgjBw+afL4q16eus93i6aN6Ipo+LzbvMGlD7YlTQHUy/j+dYBxSK9hebfWXNsDPR6FV9Xnged7UYbvAwfiz6otBbZq5kVEdgeeBUYBD+F3Wg4HvgZMEZFjVHW7cuybO3+mAa4Plm3hr+QEmzDDBvkfSk/BISQZythOA67MfTT9xsg9BkdXvFSPazJ+/hiEoGUw+H6O20zCxBdFw9ObMaZzJ++gqDPtVeCchIkv6o17FRmPgUYQJ1/AiEG99QFLmPjb0cqLZ2pT87UCeBvqIZ1BIhF0Y8NlwEAPhDIOIPPJckin9yHcZdOdSZh4dwGUekww0nsVQNSZdhYwzHedVNQ33ZW6TG2PowQWC1MnXbsb8K02f49N+XXCxOf2tRx1DXddHXWmXUprqs2sTMcMx1lTDy2tXzaqB+Dn4+x3Kgc5FbKpb2deos601xAZTNiFjNJmwCECylUJM+d3fSepT8LEX3LF/YlsdGRo46jhB8pxX4K2aJ8A5ap6oIjMwI/QWvREnWkX4DjTQ6EQ4KGlEWRjk58zVLVJYOfeGOTaUhImrlFnthBMcAAAIABJREFU2pciHzb4ZmSOA14w6BikxkF1IiJfoIf59bKUlUmp+M/H2NHdK/89JepWDwHux3VP0vIwkt/Qdh0wamsio24LS/T9+Wla/7yvHFqdcUx5KOOB66ArVqG+8n2IkTUtsdLzvyLwp3nJ+3otAEtvEYvU7I+XuVw2BgNN2YDrnkE1zceRjx5e2PraGx6ZopO9LyiGkcuvA5Pwg0x8aRuu8zt8Beyrqnqmqn5HVU/Cz9mwF3DTNku6nZIw8VaCvEAAoQ0tVD70FkPveYGhd73AkHue/++oW71d5rYa+s/6IZlBDumVId9ETju43x+RMPH/9NrNPG927qaJtE0wflpFenNgoyiIDrp4ItlQyJtmtvhXUO96jUTD3d8RWKgQmDs6mGQLXkWYk0d/sVf9THqTW38y4pAX542fduIxZZvrUGgmk4GWFshkMG7eptsAhUji6UfCc4IE5saAUYm61V40VJ03cNMA4F2gLE/AGPBN7r9RQFnOb+uwAuoIagw4DrKx+djJFRf1ilnXtrJ0RWalBgMrIvnnt6YM++LQqHvu88BBqEKkpGNboHpuwswpmB+5wRiPjLfOrFjjjaho9mfkDWoMmkojrusQDk+dOvKKiu6v1n/EIjV7RN1zbwHuRcFpTpEeXo5sbPLtN1TTApWFVMCyJEz8NolEngb8lBZZjPFnbcJhpKTkiilVl27VzOcjTzS/lK13sx5s6LH1zxZwE45MxpiINCY7HRKAemBEoRWwLMtZvAQY6hhafGf+4B17XmBhYko0lb7DpDPvRMPTe11J3RaizrQzNJN+E/B95DvxibfwkfmtL722oyhg0I0SJiLO1iw9ESBI+rlAdetjjQazYDFgMdA5AeEPgSbgQhEp6oa1PwnyAvmKatojtC6I1u4bG38J1R4nzSx2/l/52Y/9/PEVh5W8tRZpandpCCrinxMm/nIv3/IK/EEHEAcdVOr3XvxQvgM+OleWWPlFpdHS85fR3PxhF0UagL4KSvJNAf/jmE6TmbQT7vomZE39d08c/YUv9NE9t5pvfnnInldeOuS0g/cv+dQ/Z427YjNFxf/2BhupTVxwDDAsYeJv9YGYHUiY+D+BjzpY7oZczLjhjo4btfLk/b81oCJSTp107X2A7w+0qRKWTJj4noXscCVM/O8kk20zt1oS8v1IFbQ1hUm23hR1q/s9L9C8J5rfU1XSJoPJ8/mOutUTvUxmEapHZPd5E0b7yVerKvEmjT8s+O4UHIMxz66svdXf8H9apySCqmJaWw/LNDfnTUNSDMQGXTJZM5n/oHo10GbeGV7XgoRCCHiP+oGO+i2prVNePgPHSeF0+nsKhfzgM6pj1JhXpwy/vMd9sj0mhNpSnJxz6qBtHnSaUnVpyZSqS6+PVV5yU7T0gr+j5suEQoIaxBi0Q5ug/wSG9nfC4ISJp8LGqUJNU4c2S6TdT8x19gJWxMLT+8U8cXLp+TK59PzTJ5ddcOrkYV88IRqePg/4W4d0HFmZxQGR373HK32hVBc13SlM6a1Y+sz5czOcGKzrOieTVtUG4BmgHDiy0IINJPxw1DSYylyLuezMkB4YC08PxcLTHYARw93wFlqiFB37fPunDxw77mJTtq+cNHREipMu3oAZWka6KoJXESYzpDSO73/TqyRMPJ0w8V8Bc1CDGy7xgxwYg5REnJN3/9r8Uw747henjrtqgL5ZiLrVByjaSMYb27azo4+CAfZNmPgWRVPrKQkTfwgYQdAOhRcsQ0pLccJhwvWtd8ZKLzi6L+67tRx3ROku4PvVhMNszveyg9YlqZSfKFQEP1kNkYSJ1/ehqJ2ZiAa9V9fFG1aB88laZPkacd5f+kSs/MIBEXBm6qRrjwLa8iLKmA4p7FJAv0R9TJj4ncAGAGfxCr+dyGSCDosIsDbqVverJcurb7Sufn7RUGbcPJVf3HcgI4a7bfU36lYLat6hsWPobGfRcrydhmFCsuzx937Z24NcPSJFU8rD86c6MhlMKoU2N/uz6C0tZ0SdaUVnwnzsMd/6H21peQS03TLFmKDzrVl/4736TcCAR9bd8a47ePDBGLNJwm1NJtGWFkxTk+OtX9+jlEYV5eLut0/pJPD/DPaYGJnQU9kioUGRKQf94LQp+103MVr1+StMJj3XqF5nmpq/h5c5DWifXRJB2gcYrkuY+Kn9rYBleWTN7WngK7n+/G2IQOUgnIryMOVlq6YM/nxBk77HIjWiqr83qnNMOPwP09DwBJ4XA9qVr9y1mhMS3pwrCyljsdBdI/4xsGQLl3W0h5MrNNlGp6ucEVmn1EldXUBEbgiCgnS79KrkxcfxkmptbtsSgXAYCYUEX8muf/rBieet+M/E7y15deIVFeWyiRdwsTJ1/NfGn3D4tceMvvONc0pWJWVd/SBebtiFky58j8inRtF01ATWHT1m5bpLDq5JmPiWR5jsIQkTrwaMpgN3KNdFqioJN6b2DK1puF2Ffu2cbC3R0PSRqHmddNrNji4DvpmE6/rPGQ73Wn6lrghMcHYHoLzcTyyc8XzfBC/zTCw8vWgGYwZVuG1JVY1hcyYYzZvsyaSz5rOnFto0JuiIHAgoCOoIhFwy46qQkoikhpcV3AxqK7kmd8MtLyO0x26E9titImHiJf2cIPQ8ICNKe5AD42VnbkIyfEjj5L2v/caU/a/rF2VszBin7IffOJ6lv13F63ekqD776JrHF+8lU8ZdNQnXqQc2MWGX5iTuB5+85azdWBQpDV7Sx39H1vghO1jkuv7IvOPeHg1N742gTL1CbPDnP1f6+vIr85h25/rbfj5h4gsLKVdXPLLujrcTJj4G+H9k33E2BU4W1909Vn7h+pGDK8uXvLHLlxuWTrj+j7eO7DKc/ZcvGbK7Pwzh+4TVN3gbeyrX0QdeeZWXbHnI+3DJhzQ0/h5xTvQGlZQI2i6bCUz7xPETT4t8lDDxojNpT5j4Xag+3LbDKNkuuNOawjQ0oQ1NI7zGpvpo+LyC9dUUHtGMNwORUhob6UYt+GnCxP9VINGKjs023qo6QVUnbm7BV2x+k3OtxX0scz6yo21djQRn9+9QyXG3hoSJvy7NrXsY8P11HCc3czkiZtBRR4YmiQhjR7ujzz190ICIJDV1/NcOVdX3nCbzeGhDCnEc3A+a+cPPj+C6l88k3biKV+be/KM36m75w5u//HqfKWDtyLG6PqiWmQy6eh0GMI2NmGTrwVPHXTVglFuAyWUXno3q8sAjfNMC/sf3yrrWWYsLIU+Q022OpnxFN/vRDvwl+jzAwpYy97Gm99JqWJERmltNK8DUSddKEJJ+16mTrt1z6qRrU0CVjBtLp4+ZAt8pRMCIfCRM/G1gN1CcxlaSE4cRWroBbWom/Mn6imjkvIEQVTXfzOgjc+fP3FTpLTAJE38kYeJhYIPv75HTDo8ZAUMqyzST+RlwWX/I1xwJh+TVpexyeCOff2gBBx7bPOFnRx9Z79VvfJ9MphLAG1zW+bSVCRPfv1hmExqpbyBbB7xgRskYJPvdM+aoqHvuvP4OXx8tv/AH2tgY38QM2enQhdszYeJ3FVCsLSJon8IEAzZthELoLmPRweVDfvGtQ78lVTry7dWDndPPLol1da3X3mpdp9DmveJl6HbwafRopyTx2PDzX3pl5JdOOGv8bqFlDYP4cKlDMul/roRNI0pmzXyMh2YyHqqF8LXdKhImfgawE1CPGv8VO4JJp4M2QwENZUaUZ46acsOHh5//8zP6Up4po7+8C5l0DDWQHWj2uuxSzQWKMhl9odimETQRmYbv0Pwz/J/+22xDzh9LcZAw8eUO+Hb8quAIiqJGcUOKqrI0VUajcdllfLir5JBFQyw8XVJhc6fZUF/OhvoIgKQzCFB+11LCMxbR9Oi7L2te7aGv0BcczYk46Xno6jVoYxO6oR5vzdrfTRn8+WIInNMtk0dcvq9JpR5A1f+SZZX2UAeLtJqEifd5BLRcEiZeTSbjkU77Jp/ZD2s4NCQ2esaDkw/5Ya92rL4+Y8geK/4z8ap5tTtN3VJT3UiE0O+f2YNLzziH6dM+V7bLqAMnAKvwo8UuBt7H78DglpXh7LYrztjRrYTDJ+BH55rZm8+wFUzA84w0tvj9lmyeMnGQcPi9ycMuO62f5euOzr6urUCfdlK2guGdd6iXQRd/gn70ieMtWXZhfwi10/GjPyWeYew5Do/9YmceuO5oMiuaK2nOMaSIhGnrBvq7JveHrJsjYeLPg5zU1lHUIFy244AITkVFzB06tGXKiBlnFVq2WKSmKhqqXgXqRxLsbHrWvr0wYeIfFFS4HhDM1J/aIQWM6yKLP4FV69hpl/VccvMlfPsbn+XzN59PVzMnjz7VvGbRR6mPIUiNMKz76Ihf/+agT5ePG7z7ktadR1WOOXUaK1blvDeB5iSyMfCBzyq1mTalYRUwOGHi63v80AUkYeLLEyY+BPgUqh4ZL/cZ0LJSmo/eg8jC1RNLXlr0t6NPuK5PQvtPLrtwmJdsea39xjl+Xx1JAyMTJv7/+ivASbGwVZ08ETlaRJ4FZgPjgV8Du6vqz1W1P3zCsjNdVV0cz+7v0kRGVW9QVdmSpVclL1ISJv4G8Alh1x8hzBhQQzoJty3bg2se+wxXvnACTy4s6bE5QKFROHDjfsMP0OZmaMqpnuKAG0JFzJv6zCOFlClh4gYkhojfAAWNVGr3UTjl5UhJyeUq3FtImbaGycMvP9KkUm+hRtq7WsGfSCaT/ajdljDx+/tDPlHdN/t/NUE46n12h3Gjz1LP9MgfoTtmXj/ivJEjQsNOPq788O99begWDUYNG+cMnnvzgXhvfkjmraXsUxm9CN+nre0Rcss7joNTUfHNROusfyVMvBgSWT4NPC5A5P2VWft+nMoKpLRkN0T+PnnoF47o7iL9xdz5M8+mo7/daXPnz+yPb1iX+G0Fn4Ecc9X6Rr8j6brQ2HxstOyCggdOmv9K4yJEeO6dfXi1bndMtiObg7O2AScInSgi3w6+K0VHwsx5AqjxTdCCnWogHMIMrSSjGSfj6gOxSE3BLBSibvXemkmvw3FGkvQNU0xok9un8fOE1nQ+UGwkTHwuqrvhpyLyvw+qIMKTb4/C+dtqIk9/QOvtizkkfNKpk8suzBuROZnUtpCFIohZMWls7vFJP7ll5KSf3FI96Se3jAMYf8DEw677yqVyy/Vn0fiXRv+a2VnlbK7DdNbct4OSex+wU8LE+31WfEtJmPi7wFkY09ohwmpFOYP/91Uii9ZQunA1FW+sWBLb45uNsTFXrI4Nu+zBWKRmmwcko271KON5KyTkbKoY5ypjjrMKNzSoSL5f/U6PlDAR2V1EHsD/8B6Jn1/qU6r6dVXtz5GC94N1Vz5fewbrrnzGLHlImPjOIB+0ZYkP+Nusw1n98xDLrxZ23vPILk0HioFYpGZ3jL4aWbJOAExZGBPJJr43qJdmpVnyL3/oqLAkzJwnUd0JaJuEizRmMC0tvllic/O5hZapJ0SHXPqtzOCS52jt3Gdtqyt/xRg3YeKbi/rXpyRM/H1g57aPwKhh6HuL0Dfno29/sHes5PyHTz7yhjNPPvHm008+8eZtGmDJDdM9cri7iR1WPu6+t/5dXbgSjMHdeSzt03Wb5Z6tFrKXSZi4lzDxKHBZB8FDLtqaQpua0VSqX8zlesD+wB+Ac+fOn/lofwuTj4SJP4U/2OmTykBJBNL+QEdqeMmRnz73+vRBF//oX/tcf0tBogC/NeeAiSYMzhvrUE+gKcj7k2si53eyV4nr3imOU7BQ9FtDMFB0a3vAACASwjQ3IxsakLX1jrpOa7T8wvdjZRd+q6/kiJXUHBR1pjXjWxk5HdwB1LS1ruoPHoxMmPghCRN/sa/k6U2CXJgHAP7gbsCCl0rRVWt9szXHpWr4bod6ZeGPYpGaDn1UESgtpXSjcXgtWcrH6RBPN4w54YSDL382VnFB5uThFz+E6quS8u6MLG16Kzbq8h88//KBg0PPLcAsW4WTvWdnm5dkMrfepoDdEyZ+wQCdpXkRSHYw7MmaBRoDkQhUVqArVlfo6vUjtL7hLJWe58WLRWquikVqXoiGzzs7Fp6+H2pWEHLD2tBlzC1F9b8xZkwifX9RDXT1J1sUwUpEhuGHep+BH8r3OeCbQeLmYuCJYB0TESc3QqKIVALH4Du2F4u8A4fW1H6I0zbypCLo/64hvHIjqLLyfyqKwsE6l8tfvrgESC0+Oh1W472HGilZ5E+CpseWEglXwtIGFGjSjQve4oWn+kvWhImvijrT7kb1EgBWrUdDLhvO3Ac35YWOm/SlW56e//uv95d8nYm61SWIVFE56DYaGs80w8pwch2t2/WQVQkzp1cSXW8rCRP/JOqc2wqU0NQCrSk/5xKKGTbodHfZmtMkmVZvzLDbgC9v7X1aU9paViqlquj8D9NbFJhixQrTOqYpiQwf7svUvQ725Nz5Mxu2Vsa+ImHif4w6014DXgEwjc2QSiElJZDxLouVnD8Ex7m0ruXeopN97vyZ77FtOSoLxQ/wfT/8wZlM4CfmGZJ7DmXkwwtDmvGOR6iP3lx9RiJT+3+9LcBxB10xtWH/wQ9WPbw0nLlkP3fl6hbGvb0Wr0U7mni1U5/I1I7Oc6miJGHiV0edabsCZ4JCSwo0aN/CYUilXYRJqvw0Gp5+aCI9u3pb7zl15BWOel6VaW6ZrOjlpNMndijQNovgIO3pk775qIn/clvv3R8kTHx91Jl2IOhrgIMqq98fgcNGECEzbiihj9cipSWjiISTsYqLj35k4XOvOGPm65c/X7XbxF1Kxs9PuxwYSfJ6yzB+9NAhsyLvrPIDiBk+G16V1NF3vyvhknI0Y25sed0YmpOULsogmwwYAmqSiBNGEcS5IeHV/rjgL6UXSZj4yqgzbReMuQrf33GqNDXn/FEqLFvZbrSiQMb7XtStPg04IuHVdk6O1oFYpGY/VXMiyK0YI7juXzXj+ZZF2cAr2WidPuuAx4GvJUx8We8/8cBms0qYiESAq4Hv4Ae1WAh8R1X/WgDZ8skTxo96llbVtghAqrpQROrwc4VdiR8oJMuNQAVwm6o2FVLe7YGEibdGnWmXA7cDaFmI0KoGTNL/O5VwWI4omTptcsVFt8xruqeQIbLz8sWXLv5mc31kZuPtrY2aSVdlzfzcVt/iqPSd1TQeNR53ZKWGVzSc8vyyB47vT3kDrsGPJDYF1SGNn9mZoX+bHziKc3XUrd4LOCPh1aa7uc5mKSkR5+hDS4e++FpyQ1Oz9miEL1Z6/uHqun8lO6tUXw8IoeX1nUw4FHyzqTHbImuvI7IHqh+xsSkY7vR9G3FcWN8oeJ44SzMXsA1KmAiOqiKC7DTa3exsxHFn/XxvMt5vv3rJZ/Z/6hZwqrbItTI+d/7Mop0dTZj4q1Fn2t+B00mlkEgEzXhIOASqnwM9ZXLFRaPmNd2zTfV4RyVh4g1AddQ5dz5qriNt2jpWFQsa0YzJWgS7wN+jbnVFwqvttVQQsfD00vpLdvv76D8ucNNjqtDSUhpOGopZbogMW0s6G9/MBB0yvx34Wm/dv1AkTPysIDz97RgPmjJBxMSggFF/wCQUPjdWev4ZiEypa/nLk1tzr6kjrygFXjTJ5H6aTgslObFsNOglt019GX9b2DvhzXl/06sNHBIm/mbUPXcaqg8Akh5aQclyf2A3tHQtUlqCNrcAhD93xYqXFrwbYtDSvTL7DBv/geclda9QBseBB1/dnYa6CFVGodnPXTzmrnfE7DwSs7weGhp5tXknZxifBKHms1oH4OeTPKgQuRULTcLENxLkfY0604aIl2OplrVscpzAfFwh5IJnDgBaThx2YWrt5J3PH/23JYtJe2tAl+O452eqIj9ykqmxjuc5XmUp7sbmIIpozjs1vttKkPcLVOsTZs4mPq2WdrqbCXsf2AVfk70a+K1qzzpv3SEiZwJnBpvZjttRInJX8P81qpoNIzwOf4r+I2BCp0t9GXgW+LWInByUOwI/h9h84LrelHuHQpw/oeZ/gMigSAvJpN+/lHAYXJfBDP8Uqr8CPt+fYsYiNaeb7439mf5kiTgm8APMjsaUlEIqjZPyGPyvxTiRSNm85H2tIn/udyUsCIN9XtSZNh5YElmeDELlSjYv0FSM3gFcsrX3MCsmydtP7XrJzjuFxq5d563b44jFt7Uk88U63pSoW32jlJb8gGSr3xnJznyJIJlMJ8sOWYfIUQmvtiiin2VJeLVLo271UDxvNSKRbB4Y2dAIqZT/DOl0RSw8fZ+69Ox3t+YeyaS2lJY4EWNUvc2Hm4dUpjby2BsHrK0P4QwPtflGdIECzxezApbDGUALUKKe53dYPS/7dzhEjfkJcG2/SjjASZg510edaW8Cc7L7nBXrfJWnvQ4J0BB1q6vFdR+sS83a7N9jLFIzCLgDGAlcXpea9eHkYZeFKS05xaxdfzLpzFVApPSdYIK3NU3pKpfMUIdVwwcx5LU0JRVrssOcDaiZgTh1Ca92Xe8+fWFImPgdUWfaR6g+7EAJ4kAq3aYISVmpn09MtQR4IhaengSWgFxcl76/g8XN5LILh+Gnc3hePS8JXK3GHIfqXEKhH2C8nXGDsaHWVPssgtBhFgxHPESOS6TuH9AKWJaEN+fBWKSmXDPpl2Vjy74GcBDwDNrq+8Chhr2OWENZRPjmGXuHdtunYe+m+k8YOlJpbIAPZrt4VeHcNganqRUQ2OhPug+aHwwYp9L+/qzZodHqhJmz3SlgnUmY+Iaoc+5g4G1gPOl08B0PIimKtJmGto4uo3VUJDJ6zocdk6g7Dm5LK9Li90vcxpzJsnSGtuxUXkdfO2BiXz7b9kB3StiutE9aXgNcswXmMqqqu/ZAhoOAizvt2y1YwFe4rqEbgtmwQ4EfAVPwc1MsB24Fbuxnn7UBTcKr9aJu9TGoeaZ5gxvZ47AGPngpEvzxev5gSjaaYj8RK7vgQDXmj+ZXq8TdpPsr0NQIZWWQThs876B5yfta+0POzZEw8Y+jzrmvRD6qPwToOFIlcnE0fN51ifT9n2zl5St33Tm0s+OIjBzujjhw35LBz7+S7NJkLjrowrEtuwx6KPLh+k+5UKEp34zDH/PK+kwY31JHnGyje0nCzLl7K+XrcxJe7cZo+LwyjEkT+MNKWSmk2kxUHOCtWMn5F4vjzJ7Xcm+PUhVkjDEbvBQOwuDBTknusSkjZhxjGhuvBKaAPlgytHJfSWV4Y/HujDtaWPVME87gQfku+7m582f2i+XB1pAwcfVNjXgPE9RdY8iGlMZ1vx2ruOgrAj+b13TPDf0p6wDnAXylyU8orOLX3uzX2nERcBEeIBwmVnbBMjzvGlRnI04Z0NJBMVO9WtVUo0jzAWNe+syuX6wsCYXDumqt/xu6LngZwqv8zpdTNZjhz6zFNSNxQ+UkNy5496nGB+ao6g2FfQ19R8LE66LOtMFAAvT49gS+tHX61fjRgwVKFZkk8GwsfJ6nrvO/Eg4fiuqzAlFjzCA/ubkkMd7IoAk9y8/7pujQCmTtxiAacW67n/2/uQOPKxMmvl3NItelZiWjzrQTGz9+//+csaNHVq3QCZLtzAcd+U8flebJecPZ+9Mbuf6OpaRTQqoVKgbBmo/CVK5Y3h5gw3Uh4+EsbY/5ULI2g7al2lHUqApyZcLMGTDt6raSMHMagF2izrTdUX0Hz4u0zbK6Ap5fIZOTRlD1bz9uSgeTQuMhzV7+gUJH2kMGZeuuI2lxnF3rWmfZfnc3iGrXA2QiskUj5Z1R1QERWntrySZsLtZIiSJyQ+d9vfFxjDrTRgEr/C9+8OjS4aeuTni1c/Kc2utMvO/mYYCz5yVvnK0it+CZ8rxJLLP4jcfihDdnYsfdvfuueuN6sbILjLa2it+g4SeL9BO0GpB5+H6OX6xLzXpvcsVFEeB3wN7AlfOa7skbfcysmBRS1bSIYIzqCWct/c0zLybX55PtlAlfvbxlUOa35e+sDuGG/I9XyP+44Tr+usP8lwBanTDxgvz220o0VL0ryiJAZFA5NLfgmxFKEFZfAF6oa7m3R0mdV368s7csVeqsTg5i59ZVK/c9ZPkfouHz/iyR8G8UThfHwZSXIA3NaEsLlJWR2mUo66aMR5JpdnpsA/hyGPxQ6TPnzp95Y++/gb4n6p773yD+jFdgrSKOtI/AAohcXJeaVTRBRgYiUWfadcBP/Ha4PTKpuC6o8U1C08EMgD+L06wVpWVmSMVKjYSnhJesegf4olH9KRmvQgeVQ2sSSWU6tO3iOqjn0XzwKMpfWYk3uAw3mUGqKjGe5z229o8/gd75zvQlW9s+R51phtISIdkapF8IoWl/jEacYBagrU0UKCtFW5LtSpXnIaURNJX2Z4ezHdxICFIZMiMGEVrTSJ5vWBqYmjDxx7bhsfuE3vx2Zq81gb332S1y0LlOdgYd+PuiN3jvnQqqBjdhMqWM3aUVjxDlpWmmHHYcLNuYe6Fg0MBpa2ckEgHHr7+qXvKx9JyZ/V1Pe/LueruPEnXOFdAPENmtbYAlGGDwxgzFXbk+aEpylLDOlhplJdCczKeUGeCPwIytsYbpq75rf7M5naG7ZM3O1ix99SCWfmc10KpIRxO0IEGgqSypPX6vGf84cfxlfZrYcuJ9N5+Msiy8uPkTjYRvw5jyTQqJ+P4+bTLqu6juuUm5IkS9TJD7KdB1TZsFsIPIVOBY4O9B5Khq4Dz84DN/2sxlTTpD2gQf+Q31ZhMP5Vh4+gVRt/qBDQcPuS01scSfJc92CrJ+X9kORHsHzQM9baAoYACJTO1H4siugCGV9kezFTQU9sMmexnIpI+IhacnYuHpWxySemHDEKY/cSlXPVfNLYtOqRzKqGGoeV/hdE0m8UYNhfUb0ey7LCuhZbjSMtKheUIJKw4r4cP1z/0VqJo7f2b5QFXAABLenO8Ar2+Ses/LGU1VvTu1SyXbAAAgAElEQVQWPu+lWKRmbCxSEwKYOunaIVMnXTu4wOIOWBImfhPwFXImqIG2v1tNZ/z6lt0OO+WpCcPE+WTtGHfR8tdVtcWkM7/F8yrUdaCltT1cd4fL+X8jUubP1robW9CMR3rDuuZ/r531sz5+zGLgVyRbobSErOlHR3ImFY0B0baZF8JBU9qabu/UhgPfryDQRmhNY/tscXtgk5eBymJUwPqKxbz3rqZaW3PbjbWrHN7+dynqOSx5vww1QsgJJgTrO7k8tim9gf8coKkU2tqKptO8k36hX1KlFBMJM0eBU1BdAKTJCazlNrbmBOzoWMmNm7Mvq4B1LPM0UJrwai8vNneEYsYqTJYtJmHiChyRIVWfItk2zSyuS2ZEGUu/egCrp+116rqjRy+IRWruikVqpve2DLHwdCeyNHNL+cvrS3b5wfyI7/Tffrztv9lEwY4L4ijiHJ8w8R6Zl/UXidTs74Ic1OaYnaXjqNMewI+BrHli4JPQJdoshGtX7MYL9UP59H6RodkDsUjNhFj4vPtU9W5Uzxnyt/coWxToaNr2jz/imx1ldBxwnCcSJh5KmHivR2Hra+rSsz8Gdsr9AElW2W0b9ZNTQDKxSM2MLcmj8uy6XR3nw2bG/ngJiy8w5YeETrxKlRLS/ui3LF/jhwpuu6fgNqYQYyCjpNxk/YK1/35r7vyZmyZcGoCII59BZN4mBzqO9h+K6jJg4+SxV16rqqtUdeXUSdd+duqka0+fOunaIYWSd6CSMPHfoqYCYQY5TaAGOdty20czKEJo/nJ/GM0oGOMPMiioC9L22+Qx8hCh/O11NJ+0Fy37jWVVZf1TT6Ye+FkrLUVn2t3bJEz8G8BQkq0l+CHA86LBjII25/jMZM0Yc9vzbGLo3PDzbe27AvLthIkfljDx7f7dduYD/hNv8RqW4zgrgYZbvjGB409tYPH8So6IrucPN47nZ1fvjirc+vBbhNuGbNTXzPx36kfuCGr6KvPJv9/Rl/68nI82943cYUiY+KKEiU9KmHgEZC8Ev55l/5Q7q1ACblZd8BWvDPAmIpfhR2AsT3i1x29r8LAdkc2aI1rys6OaI3a+/knO565zcEIA608eT2rnKob/bQGhhjT48V5TiBxYl5r13rbeMxaeHgKOU9U/bzhp/K5DHvvYlyXkopmsY6hCWakfJQmyszUe8N2EV5t3tLYYzRGzRJ1pGxGn0jd3gfaOUU50J3HOknAohe9Dee+8pnu67MBfNHeGvvvUCDQM49586vkP/i9VP46JBwGjITva7Y8gmp1G4Cxb3X5P12kPymF0OvBJwqv999Y8VzERDU2/A9XLwFcy28wSOyAAGUR+Cny/c5CDqDNNJBwuO/bxDY3/PmmIaHkpksqgqZSvfIVc3yQs6zsXCvkzbiJoWRlNkypID4mkX3vxzp+Zpqb09mB+kUssPP17avSmwHcmQHICEPhrGTkcZ5Af9Cf4HZrxP/Znz50/c4eZDdgWYuHpo9ToG+LImGxdVqNk25DWsYOILG9sUwzEkTbFwYs4uJlAOfP9OvymxpF2RQKQsIuqXPtoatYmFgjFXnd7o32OutVViFxDOHy5ZNKjcofKNM97JeuP1CEwXwehAG3GaCNoE3BqkHS3qOkLc8R814o60+aMndB65mXXL00dPbmxwu9+Cb++c93DMy6qmlJa4oaBv9/789Fn/uWXY8YBK7IDrpPLLnTqkn/5QW/J2Vv0pzliPqJu9Xj86OKfRzgCJYRvWphjk9wmz/8Bp9elZ/e68rAjmiNuUZ4wiyUf75mX79lHDrtURChd2srQx99q/2gDChFRMxnYZiUM+A+uuzfpDFXPrmrfq3SwV5bWFJrt7Kp5CDhngCZcBHF2B1bQ1hBu0ua5qHlYU6lXgMPr0rO7dIpbv2D/0csejDH00UZ09XqaW8cduRO5XiS5KF44e9OghGfAaL04clCdV7t4m5+tWFC9HJEnUf2lKqM2LdD25QkB3wP2i0VqfgNMQuTfUlnxI+CzJhKR9/45DkKtaGuqLRcZApSWtifLRBA3GDhQRZqbee21+H9vz7MJdenZ/xUNVe+O6qWb+BBI1lcJ32SoojxXCc528udOnXTtuLnzZ64ulMwDlbr07FXRUPUeqroOJdL5jzvU6HVQqHJxU56v/AYzCG1ag1/+BeBQIKNpb3LCq/2XyKwb+vBRipaEV1sPXA9cHyupGS7GLMPPn5qfbNAIkRyTQzJAKDD7+mfCqz21T4UewCRMvC0q7EnHlv/mtFjFLrfdU//+/IXp5m/8YO1r2U76xT+Hi3/O0txz57Xca0T+UmCJBx4Jr/Zj4I9Rt/oulAsAF7gHoQQYhtKAUhmUs/QiVgmzbDXLWPzxKHZ5bgRjjipdk+rKTv7GWKTmBeC1utSsHnU0Y+Hpk4E4UAmgQefMlAluMNmluZ06BfUMoB8A+ydMfLNJB4udhFe7OhaePgw/QmhV3qFUEXCcQzC6Khae/gdx3ZvnJe/rkA8v6lZXlOx62GXllUlaPlpFNuBHx5mJjoSWrsNUluE0tGTvmUR177p0fEVvP2d/Etiu3xcLT39YVZfj5xTsSLsPE4h8FvgsAI6DafJftaZaWL2hEtJNmDIXN6ltviPtM7X+tTSdQUpLAWg0Gxa0tm6/CliWRKb2C1G3eqbCn0U4Ol8ZKW+fWOk0GxnGT0lilbAtIJGpbYqFp49GOAS4CWmPXCuNm6lqqmRbhGAmxwNqgSsTXu2GqFtdCpiEV5sn4+2OSV3rrLWx8PQ9gauA48WRw1RVOvpM48dFUQhC0S8QZC/1vE+jDMNPZGvZAp54pmXtE8+0rO1vObZXEl6tB+RGOM4A2f5El9GULVuPVcIs28SHvPX8cEYfJTm5o6AtRhdAFarPIfJ+LFKzT1f5amKRmlLgl8Ao1HwPx3kJaLf2NupH6ALMEBc3m31GFdxQ1uHfIPxVxLmsLj17QCtgWerSs+tj4ekjgI/JmwBZsj5Gw4Hr1PO+FwuftxaRlcBNqnocqlOSSxp3lapgQs1xuhwNByAcRtJppCEJfhfiq0AiYbYvBSyXuvTsBmBQNFR9vcKP8iqnnWdxykthvf9dclCGHdPEutsVSSmURIL8Kfj5hDoMFiiaSm+UUOii51r/8em+eJ5iJOHVzgeOiYXPuxT0DhSnw3spieQxBW1jOvBS30u5fVCXnr0BeAx4LBaePl3hNqBSVKXNvNDpPCvpeKheh9GL1aFcHHkOuKQuPTsNkPBqt4s2tbepS89eAnwrux0LTz8BOBFHWtXoKOBWlGbQFJ6aYCYN4NV+ENdisRQRVgmzbBMbdd3GNKl1kYamoQRa1ybdKL9jtReQiUVqngIewU8cuB5/dLsCOA64FNUIjnM2xmxyGQ0iSUUaS1Bp8tUDzwPXRcLh5yTknjyv6Z6WzucNdOrSszOx8PTxwP0gn+sYiaSzBaIIIiOAEao6K7DXZNS4JKvXBBYz7bnHOp7pCGocSKcVWAv6OnBNwsTzhr3fHklkan8cC0//D/B94JDNlZXSUnKNi9yQi1QZ8MqQwYPQ1eugNe3HrRPSwEqUt4E3UP1lXfIvq0Tu22GUsCx16fv/FIvU1AGLyP0GGUUln08eACsLJN52R1169uxYpGYOcAJqKtR1L8dkJmM0rK6r4qgEQQ2OqkvXvgLM7GeRBzR16dlPAk/2sxgWi2UAYJUwyzbzoibuONY7rQG4DrSsgxqW69Qt4qB6AiIn5LlMTpKbLkbD02nfrKM5iYweia5dByJrSWcurMvUzu3FRyo66tKzM8C0WKTmWFSf3pJzRCQwz4R1KyJQ5kJSciIe+rmFcv3CxBEFtyqYGdohqUvP/lssUvMwan4BXJ1PYfUTtea4Goqw5rJGwgdUYF5uxdtvAgwfBEpSmpMTHn3/l1aJyKEuNWtpLFIzFNgHcZ5HjUNzM1TmTVgNcF8BxdvuqEvNMrSbvf09uz8WqRFERoOsqUvNGhDRYy0Wi2V7wYaot2wzSZqTCa/2JmAEcPcm9vB5Q0JtQnsvt6uInRL4ijQ0oRsbjIwa+VNn7z1GJ7ZzBSyXutSsfyNOKeJc1m1hoW2mzEs7pEcPDt6tIqGwr0ggCLIBmAIyA3GG78gKWJa61CxTl579ddCDgfX56qTBQODHJBUVaGOG1LMNJFMbPnnl5dt/vbj+lQcZWrm3VcDyU5ea1ViXmvUSsD/izNGmltcB8kTsfX3u/JmfbHIByzZTl5qldalZK6wCZrFYLIXHzoRZeo2EV9scC0//An649OPyFura56OdbEjfDufhBzkg8GVoSf6kruHWH26rzAORIMDJH2Ph6U34JopsiaLrfrSaTEUJblMriEFCIRWRJHDMvJZ73+ljsQckdenZrwHDYpGaB4Ez8B2VIwCyth4dOxyqyjK6Yl2zlJZULMssfOyd9PPPkYT6Dz9Zv3DhvI/6U/6BQF1q1jv4SceZOunaXYCDgXeBScAHc+fPLPpw3RaLxWKx9BSrhFl6lbr0bC8WqZmGmrdBh/f4AhIEmsiGmQ8UDBFpVnQMyiiEpkSmdrsNEtED4sA3QA/Le9S0vz8cByfl4aQ8/qMv3JnOtLaW6qDy/cJH3ziv5V6rKHTPOcAwfD/GEkR+L3CuLF/3AfDpOm+Oly/HiaVnzJ0/cwntScff709ZLBaLxWLpS6wSZul16lKzVuKbJhILn/cc4hzZpYlhPgKTuWDjQ5C/IHJbIj2rAdjhTeWy1KVne8DhsfD0Y4A7gN1Bg+gbQZ4f1wUvA8agqHlNn/79OlatAcBbxSeZhVYB2wKCqJ7Z0MgtwCXBYrFYLBaLxdJjrBJm6WP0JJA6RI6kZ/VNgReByXXp++u7K7wjU5ee/QzwKYBYePowlDMRbkfEFVVVx2kGuedxb85q7ZE2bLFYLBaLxWLpC6wSZulT6tKzWwj8w2KRmj3wFauheYpmgC8BHyJOObCmLjXr+YIJup1Ql569DvhTLFLzD2AMIi2JdO0CAJHaG/pVOIvFYrFYLBYLYJUwSwGpS836IBapGQ5U4UfmHA8sBHYF3g3CKFt6gbrUrFXAqv6Ww2KxWCwWi8WyKVYJsxSUwLdmQ7C5Lli/3U/iWCwWi8VisVgsBcfmCbNYLBaLxWKxWCyWAmKVMIvFYrFYLBaLxWIpIFYJs1gsFovFYrFYLJYCYpUwi8VisVgsFovFYikgVgmzWCwWi8VisVgslgJilTCLxWKxWCwWi8ViKSBWCbNYLBaLxWKxWCyWAmKVMIvFYrFYLBaLxWIpIFYJs1gsFovFYrFYLJYCYpUwi8VisVgsFovFYikgoqr9LcOAQ0TsS7NYLBaLxWKxWCzdoqrSeZ+dCbNYLBaLxWKxWCyWAmJnwraB3BmxfBquZcfG1g9LV9i6Ydkctn5YNoetH5bNYevHwMHOhFksFovFYrFYLBZLAbFKmMVisVgsFovFYrEUEKuEWSwWi8VisVgsFksBsUqYxWKxWCwWi8VisRQQq4RZLBaLxWKxWCwWSwGxSpjFYrFYLBaLxWKxFBCrhFksFovFYrFYLBZLAbFKmMVisVgsFovFYrEUEKuEWSwWi8VisVgsFksBsUqYxWKxWCwWi8VisRSQUH8LMMC5sb8FsBQ1tn5YusLWDcvmsPXDsjls/bBsDls/Bgiiqv0tg8VisVgsFovFYrHsMFhzRIvFYrFYLBaLxWIpIFYJs1gsFovFYrFYLJYCYpUwi8VisVgsFovFYikgVgmzWCwWi8VisVgslgKy3SthIvI5EfmNiDwtIhtFREXkL92c44rIZSLylIisF5EWEflQRGpFZFKnspcE1+xquSLP9e/q5py9e/s9WPLT1/Uj55wqEfmRiLwpIo3Bvd4SkdtEJJynfJmI3Cgi74tIUkRWicgcEdmnt57d0j3FWD9s+1E8FOD7srib31pF5Po897DtRxFQjPXDth/FQyG+LyIySkR+GnxPGkRkrYi8IiLfEpHKLu5h248CsSOEqP8+cCDQCCwFNtvAiMgg4CHgJOB14G4gCYwDjgMmAfPznPpQUL4zL2/mdrcCG/LsX7M5GS29Sp/Xj+CjVheUeRSYC4SBCcC5wDeBdE75EiABHINff24FxgPTgFNF5CRVfWHrH9nSA4qufuRg24/+p6/rx6+AIfkuBXwP/xs+t9M9bPtRPBRd/cjBth/9T5/WDxGZALwAjAKexK8LpUAM+ClwgYgcqaotOefY9qOQqOp2vQAnAnviN0onAAr8ZTPl7wvKzOjieLjT9iVB+Ut6INNdwTkT+vv97OhLAepHOX6juB44Mk/5EEGqiJx93w3uEQecnP1nBPvfzt1vlx2uftj2o0iWvq4fm7nO5OA6r+Y5ZtuPIlmKtH7Y9qNIlgJ8X34blP9hp/0u8Fhw7KJOx2z7UcBluzdHVNUnVHWBBrVoc4jIwUANUKuqt3VxvXwj0pYBSgHqxxX4jex3VfX5POUzufcWEQnOAfi2qpqcsg8BTwOfAj7TnbyWbafY6oeluOjH78vlwbrDdWz7UVwUW/2wFBcFqB+7BeuHO5XzgP8LNkfm3MO2HwVmRzBH7Ak1wfp+EakCTsefhl0LPK6qH2zm3INE5Gr8qd5PgCdUdWk395sqIoMBD/gguMfGbXoCS1+yNfWjBn/0aHZgGjAV33xkCfCIqq7tVH53YBdgvqouynO9ufhmBycBT2zT01h6m0LUj1xs+zGw2JbvSxsiMjo4txGY1emwbT8GLoWoH7nY9mNgsTX1421gCnAq8Fp2p4g4+N8aAzyeU962HwXGKmEdOSxY7wosBIbnHFMR+T3w1WAUoTNf67TticidwNWqmuzifr/rtN0gIt9V1d/2VHBLQehR/RA/oMKBwGrgi8B/0fFvrklEvqqqf8rZt1ewzud3CLAgWOcN8GDpVwpRP3Kx7cfAYlu+L7lciu8zeJeqNnQ6ZtuPgUsh6kcutv0YWGxN/fgpcBrwYxE5EXgViOD7hI0BLlPV13LK2/ajwGz35og9ZFSw/iW+E+M+QCVwCn6l/zLQORLVIuAq/MpbAeyE70y/GJgB5OtAPQVU4/8xleGPPlwTHPsfEbk8zzmW/qen9WMYfqd6OHAz8GP8kasRwGX4MyB3ishJOedUBev6LmTI7s/njG3pXwpRP8C2HwOVrfm+dCAwF7os2Lw9TxHbfgxcClE/wLYfA5Ue1w9VXQUcCfwv/uzVNcBX8furc/ADQeVi249C099OaYVc6MbxEXg/OP4W4HY6diD+tP1GILIF9xoPrAuud+AWyndaUH515/vbZeDVD2BsUF6BP+S53lXBsXk5+2q6kSHa+Ry77Dj1oxv5bPuxHdWPLq6R/ft/pYvjtv0o0qUY6kc38tn2YzurH/gRdt/En8GaCgzGnwGbgW+uugKYmFPeth8FXuxMWEey4Vr/rp2m/FX1DfxZr0r8EYjNoqofA/8MNo/fkpur6j/w/clG4Ds/WoqLntaP3NGk/81zvey+w3P2Zc+pIj/Z/flCC1v6l0LUjy6x7UfR0xvfl+wsRVezHLb9GLgUon50iW0/ip6tqR93AfsD56jqXFXdqKor1A/scR0wGvhhTnnbfhQYq4R15P1g3VUFWx+sy7bwequDdUUPZNiacyyFoUf1Q1WbgY83c06++pS9R1c213sG665sti39RyHqR3fY9qN42abvi4iMwg8TvbmAC7b9GLgUon50h20/ipce1Y8gEfNngHWq+mae8tnAGofkuYdtPwqEVcI6krWP3a/zgSCBXbYCLt7C6x0RrD/cksJBxJu98ad780WmsfQvW1M/ujwnZ1/ub70QPzLeJBGZmOecqcH68TzHLP1LIepHl9j2o+jZ1u/L5/EDLtyvXQdcsO3HwKUQ9aNLbPtR9PS0fkSC9WARiXQ+h/bQ9Kmcfbb9KDBWCevIX4FlQLWIdDYBuh5/KvYJVV2R3Skih3a+iIg4IvJd4Cj87POP5BwbIyI75zlnEP7UcSnwqKqu3PbHsfQyPa4f+MkSDfAdEcnNx1EK3BRs3p/dr77h9R+CzZ8GoWSz55yBHx72HeBfvfJElt6kz+uHbT8GNFtTP4BNAi50mfvJth8Dmj6vH7b9GND0qH6on97kXfzgTx0CdgTfl+8Hm49l99v2o/CI/863X0TkTODMYHMMfib5D/GTzgGsUdVrcspHgX8Emw/i20gfARwLrAKOVdUFOeWzjpJvBGWrgGPwRyuagbNUtS6n/An4IxrP4U/prgLG4Ts8jglkO1FVl/TKC7Bslr6uH8E5PwBuDI4/DCSD++wJPAucrDlpDIJRrceBo4GX8RvJXYBp+KNWJ6nqC73w+JZuKLb6YduP4qIQ9SM472T83/1VVT2k8/FOZW37USQUW/2w7UdxUYD+6Sn4SZkjwAv435My/BmtXfHzwx2pOfkobftRYPo7MkhfL8ANtEcgy7csznPOgcAD+PbRKfzp2d8DO+Up+zP8UYFl+J2nZuA94H+A3fKUH48/UvVqcP00vjPki/iOkpX9/c52pKWv60fOOWfjhwbeGNSTt4Pfu6SL8uXAj/CjGrUG94oDn+rvd7YjLcVWP2z7UVxLAetHbXC9GVsol20/imAptvph24/iWgpRP4ADgHuDcimgJfi+/BcwpItzbPtRoGW7nwmzWCwWi8VisVgslmLC+oRZLBaLxWKxWCwWSwGxSpjFYrFYLBaLxWKxFBCrhFksFovFYrFYLBZLAbFKmMVisVgsFovFYrEUEKuEWSwWi8VisVgsFksBsUqYxWKxWCwWi8VisRQQq4RZLBaLxWKxWCwWSwGxSpjFYrFsZ4jIkyIyYJJAioh2Wsb0t0yW7QcRuaZT/bqrv2WyWCwWq4RZLBZLkZJHOeluuaS/Zd4GPgJuDJbG3ANdPGuriCwWkbtFZJ/OFxORE4JyT3axP3dpFpHlIvKUiPxMRD7dlw+aI0uFiJwvIrNE5D0RaRKRBhF5WUS+KSKRLbzO93Oe5ZQ8xy/ppt5c0an8hC2sb8fludfOIvInEVmW8xv9SkSGbkb+T4nIHBFZJSJJEXlfRG4UkbLNnHO0iPxTRNaJSIuIvCkiV4uIm6f4s/j16tbNvkiLxWIpIKH+FsBisVgsXXJjnn1XA1X4HcoNnY69HqwvAsr7UK6+YLGq3tBNmdz3UQUcjv+s54jIsar6ev7T8vIRcFfw/wgwEjgYuAa4RkRmATNUtTH/6b3CccBfgHXAE8DfgKHAZ4GfA2eLyMmqmuzqAiJyMPADfMV1UDf3e4j2OpLLy522N5C/7gGMBy4F1gIvdpJld3yFZ1Rwr/fwf6OvAVNE5BhVXdvpnCOAx4Ew8ADwMXBS8EwnB8/f2umcM4C/AkmgFv/9nQ7cAhwDTMstr6rPAs+KyIRAFovFYul3rBJmsVgsRUo+pSSY7aoCfqWqi7s4b0mfCtZPdPE+fgN8BV85vaQHl8ur9InIQcA9QA0wDJi6FaJuKSuAC4C4qqZyZLgGeBI4GrgS+EW+k0WkFLgXeAlYCFzYzf3+pqp3dSeUqm4AbujinjcH/72ns3IE/A5fAfuqqv4m55xfAl8HbgKuyNnvAn/GHzA4Q1UfDvY7wBzgnOC8/845ZzBwB+ABJ6jqy8H+6/GVuc+JyHRVnd3dc1osFkt/Ys0RLRaLZTsjn09YjhneDSJyqIg8IiL1IrJeRP4qIuODcruJyGwRWR2YeT0hIgd2cZ9yEfmuiLwemNI1ishzInJeIZ4zoC5Yj+yNiwWzaacAq/Fnb87sjet2dS9VvS9XAQv2N9CueJ2wmUvcDEzEVz5NX8iYi4iEaVd0b+90bHcgBiwGftvp1B8CTcCFIlKRs/8zwD7AU1kFDEBVDfDtYPMKEZGccz6H/1vPzipgwTlJ4PvB5pd6+mwWi8VSaKwSZrFYLDsWhwFPB/+/A9+k7GzgURHZO9jeGX826P/wO8oJEelg6iYiQ4B/A/+FPyvxJ+Bu/A7yLBH5Sd8/CuArTLCpSd1Wo6qrgNuCzfN767o9JB2sM/kOishJ+KZ131XVBVt4zYMCv6nviMiFIrJzD2X6LDAGX2l6r9OxE4N1XaBEtREolc/gz3gdmXPopGD9SOcbqeqHwHxgV2C3LTkHeApoBo4WkZJun8ZisVj6EWuOaLFYLDsW/w+4QFXvy+4QkT/i+/k8C/xCVW/KOXY98CPgC3QMbPAr4NPAtar605zypfi+Td8TkQd66Ke1WUTkhpzNwfgK5THAP/B9qHqTJ/FnVg7v5etuKZcG602UDRGpwvdnexr4dQ+u2dkfyhORO4GrN+d3lsPlwfq2PMf2Ctbzuzh3Af5M2STgsR6cMylYFnZ3jqpmRGQRsC++4vZuF9e1WCyWfscqYRaLxbJj8e9cBSzgbvxOfz05/jcB9+ArYQdld4jIcHxfppdzFTDwzcJE5FpgMr5fVa8pYfhmbZ15B7g/mG3pTT4J1r1i5tgTROQrwBT8d/enPEV+g++vdoKqbkkqgkXAVfimm0vxfQqPxTdnnIGv0NZ0I9MEIIofkOOveYpUBev6Li6R3T+kH86xWCyWosMqYRaLxbJjkc9sb1mwfl1VvU7HsspIrunaYYALaKfZqSzhYL1J6PhtQVXbfIMC36J98ZXG+0RkX1W9rhdvl71Xt0qOiJzApr5bi7ckCEaea52NP8u4AjhHVdOdjp+DH4DjysBkr1tU9V/Av3J2NQNxEXkeeAM4T0Rmquobm7nMF/Hfyd15AnJYLBaLpYdYJcxisVh2LPLNIGS6OhaYeEG7YgUwPFgfFixd0V3I9K1GVZuAFwOlZSnwbRH5g6p+3Eu32ClYr96Csiew6Szdv2gPgb9FBEFAZgOrgBM7K1kiMoz/397dhUpVRQEc/69LQSASQUT1kFpEEEFQikR01QSpoCAiyAzMMJDooaKXlCB9qSAypEiCntI+yIcgsAdDMsKyXn0xizCREOwDiYhAdw9rT/c4nBlnvO6HnlEAAAQASURBVOPM1f4/GIY595x91nCHy12z9l4btpPT+d4eZuw2pZSjEbGbXPc2TSZkbXFdAqyrL99pO4eZz87lPX7eOd7cVmFc10jSnGNjDknSsDr/CG8tpUSfx4q+o4xAbad+iPxS8bYRDt2J/cAAMbzU8t6XD3OziHgY+Bg4DiwrpRxqOe064EpgJXC6uXEysLaes6cee2bAW3eSzHl9zrkfuAbY1yMuyN8B5PqtNjfW5+ZarpFeU5PFReSXCgNVCSVpUqyESZKG9S3ZEv2uSQdSXVGfR/LFYkRcRa6VAuhePzdyEbGGXJd3jJYKWMOvwLs9fjZNJi2fkdNLDw54+6X1uV/S0mnI0asKBrnZNMCqiJhqdkiMiPlkA5W/gG8a1+wFNpHr315uHCciricTrSNdse0lK3f3AB90xTBNdmD80imTkuY6K2GSpKHUFu47gcUR8WLddPcMEXFDRCw637HUKXyLyJbu+0cw3q3AHrLitLu5f9X5EBFryeYnPwPT/dZ5lVKOllLWtz2Yee+v12OfN+6xuOW+UxHxAnAHcIL2lu9ExAKyq2Gvhhyd2H4kG38sJDeYbtpMVtreq9NIO/aRHQynI+KBZmzAq/Xl9q7mI7tqvI8031ftytnZFmHWUzUl6XyzEiZJOhdPk5WXLeQmvF+RU+muJRtyLAFWk535RqKrCcg84Gbg3vp6Yynl+BDDLWyMdymZdN1eHwA7gA3nHOwAImIF2f1wiqwkrTtzX2IA/iilvDHLW30XEQfJNV/HyHVTdwK3kNWpNaWUkz2uXV/jG6Qhx1NkMrgtIlaSCdZScmrn92TV6z+llFMRsY6sbu2KiF1kMroSWEzuLba165qTEfEkmYx9EREfAr+Re5jdVI9/dJY4JWniTMIkSUOr/wwvI6eqPQo8BFxGJmKHgWfJitIoNZtfnCLXM30KvFlK6b5Xpzr3T4+xFjTG+5ts5HCY3G9s5yj3N+tjATMzUp7occ4RslvibLxG7nd2N9na/jSZ7LxFVs5aq2+1wtmJq99URCCrYbU6tYWcLngf8Au5v9zmUsrvLdcciIglZLVsFTCffM9bgFfaEr9Syif1s7eJmc/dD8BzwLYB2/ZL0kSFf6skSZNUG0vsG7aZxVnGXA28TyZUj41qXF246l5nP5FVvccnGoyk/z3XhEmS5oJljW5/V49gvAfr89cjGEsXsIh4vib6I5saK0mz5XRESdKkbe56/ee5DFIrHRvIZhPT5PqnHbMJTBeF/Zz5GRvHVFNJ6svpiJKki0JELCebPJwgNzTeWEqx+iFJmnNMwiRJkiRpjFwTJkmSJEljZBImSZIkSWNkEiZJkiRJY2QSJkmSJEljZBImSZIkSWP0L8Joy3969LXeAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(14,4))\n", + "plt.scatter(ff.time[0], ff.flux[0], c=cnn.predictions[0], s=5)\n", + "\n", + "for tpeak in ff.flare_table['tpeak']:\n", + " plt.vlines(tpeak, 0,2, color='k', alpha=0.5, linewidth=5, zorder=0)\n", + "\n", + "plt.ylim(0.94,1.3)\n", + "plt.xlabel('Time [BJD - 2457000]')\n", + "plt.ylabel('Normalized Flux');" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.96, 1.05)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(14,4))\n", + "plt.scatter(ff.time[0], ff.flux[0], c=cnn.predictions[0], s=5)\n", + "for tpeak in ff.flare_table['tpeak']:\n", + " plt.vlines(tpeak, 0,2, color='k', alpha=0.5, linewidth=5, zorder=0)\n", + "plt.xlim(1660,1666)\n", + "plt.ylim(0.96,1.05)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You'll also note there is a flare at time$\\sim$1665.5 that was not identified. As there was a significant gap in the data and the CNN cannot handle data gap, the cadences around this region were ignored. Hence, that flare was not identified. \n", + "\n", + "Additionally, the light curve looks to have a few flares at time$\\sim$1663. Zooming in, these don't look like flares. This is better seen when the eye is not guided by the prediction assignment of the neural network:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(1.1, 0, 'Time [BJD - 2457000]')" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(14,4), sharex=True, sharey=True)\n", + "ax1.scatter(ff.time[0], ff.flux[0], c=cnn.predictions[0], s=8)\n", + "ax2.plot(ff.time[0], ff.flux[0], 'k.')\n", + "for tpeak in ff.flare_table['tpeak']:\n", + " plt.vlines(tpeak, 0,2, color='k', alpha=0.5, linewidth=5, zorder=0)\n", + "plt.xlim(1662.5,1663.5)\n", + "plt.ylim(1.01,1.035)\n", + "plt.xticks(np.arange(1662.5, 1664.0, 0.5))\n", + "ax1.set_ylabel('Normalized Flux')\n", + "ax1.set_xlabel('Time [BJD - 2457000]', x=1.1)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/docs/getting_started/other_features.md b/docs/getting_started/other_features.md new file mode 100644 index 0000000..6a8ca6c --- /dev/null +++ b/docs/getting_started/other_features.md @@ -0,0 +1,100 @@ +# Other Features + +This page showcases a few additional helpers in `stella`: fitting flares from predictions and estimating rotation periods. + +Backend +------- +Select a backend before importing `keras`: + +```bash +export KERAS_BACKEND=jax # or torch +``` + +Imports +------- + +```python +import numpy as np +import matplotlib.pyplot as plt +from tqdm.auto import tqdm + +from lightkurve.search import search_lightcurve +from stella.neural_network import ConvNN +from stella.models import get_model_path +from stella.mark_flares import FitFlares +from stella.rotations import MeasureProt +``` + +Predict with a packaged model +----------------------------- + +```python +lc = search_lightcurve(target='TIC 62124646', mission='TESS', sector=13, exptime=120).download().PDCSAP_FLUX +lc = lc.remove_nans().normalize() + +cnn = ConvNN(output_dir='.') +cnn.predict( + modelname=get_model_path(), + times=lc.time.value, + fluxes=lc.flux.value, + errs=(lc.flux_err.value if getattr(lc, 'flux_err', None) is not None else np.zeros_like(lc.time.value)), + verbose=False, +) +preds = cnn.predictions[0] +``` + +Fit flares from predictions +--------------------------- + +```python +ff = FitFlares( + id=np.array([lc.targetid]), + time=np.array([cnn.predict_time[0]]), + flux=np.array([cnn.predict_flux[0]]), + flux_err=np.array([np.zeros_like(cnn.predict_flux[0])]), + predictions=np.array([preds]), +) +ff.identify_flare_peaks(threshold=0.5) +flare_table = ff.flare_table +flare_table[:5] +``` + +Plot a detected flare +--------------------- + +```python +idx = np.argmax(flare_table['prob']) if len(flare_table) else None +if idx is not None: + tpeak = flare_table['tpeak'][idx] + fig, (ax1, ax2) = plt.subplots(figsize=(12,6), nrows=2, sharex=True) + ax1.plot(cnn.predict_time[0], cnn.predict_flux[0], 'k', lw=1) + ax1.axvline(tpeak, color='crimson', ls='--', label='flare peak') + ax1.legend() + ax2.plot(cnn.predict_time[0], preds, 'orange') + ax2.set_ylabel('Probability') + ax2.set_xlabel('Time [BJD-2457000]') + plt.show() +``` + +Estimate rotation period (Lomb–Scargle) +-------------------------------------- + +```python +mProt = MeasureProt(time=lc.time.value, flux=lc.flux.value, flux_err=(lc.flux_err.value if getattr(lc, 'flux_err', None) is not None else None)) +per, amp = mProt.run_LS() +print('Best period [days]:', per) +``` + +Phase‑folded view +----------------- + +```python +if per is not None and np.isfinite(per): + phase = (lc.time.value % per) / per + plt.figure(figsize=(10,4)) + plt.scatter(phase, lc.flux.value, s=4, alpha=0.5) + plt.xlabel('Phase') + plt.ylabel('Normalized Flux') + plt.title(f'TIC {lc.targetid} — P={per:.3f} d') + plt.show() +``` diff --git a/docs/getting_started/pipeline.md b/docs/getting_started/pipeline.md new file mode 100644 index 0000000..b237c92 --- /dev/null +++ b/docs/getting_started/pipeline.md @@ -0,0 +1,22 @@ +# Pipeline + +Typical workflow: + +1. Prepare data with `stella.FlareDataSet`. +2. Initialize `stella.ConvNN` with desired backend. +3. Train with `cnn.train_models(...)` or predict with packaged models. + +Example prediction using packaged model: + +```python +from stella.neural_network import ConvNN +from stella.models import get_model_path + +cnn = ConvNN(output_dir="./results") +cnn.predict( + modelname=get_model_path(), + times=lc.time.value, + fluxes=lc.flux.value, + errs=getattr(lc, "flux_err", None).value if getattr(lc, "flux_err", None) is not None else np.zeros_like(lc.time.value), +) +``` diff --git a/docs/getting_started/pipeline.rst b/docs/getting_started/pipeline.rst new file mode 100644 index 0000000..3acfcbe --- /dev/null +++ b/docs/getting_started/pipeline.rst @@ -0,0 +1,85 @@ +.. _pipeline: + +Pipeline +======== + +This page shows how to use the high-level pipeline API built on Keras 3 with the JAX backend. It loads a converted ``.keras`` model, runs predictions on a TESS light curve, removes obvious false positives, and fits flares. + +Prerequisites +------------- + +- Install requirements and select the JAX backend:: + + Pipeline + ======== + + Let’s keep things simple. You bring a TESS light curve and a Keras ``.keras`` model; ``stella.pipeline`` takes care of the rest: it normalizes, filters bad cadences, runs the CNN, and helps you mark real flares. + + Setup + ----- + + - Install and pick the JAX backend: + + :: + + pip install -r requirements.txt + pip install -e . + export KERAS_BACKEND=jax + + Quick tour with TIC 62124646 + ---------------------------- + + We’ll load a two-minute light curve, clean it (remove NaNs, normalize flux, drop non-zero ``quality``), run predictions, then identify and filter flares. + + .. code-block:: python + + from stella.pipeline import ( + predict, predict_ensemble, predict_and_mark, + mark_flares_from_preds, remove_false_positives, + ) + from lightkurve.search import search_lightcurve + import numpy as np + import os + from stella import models as stella_models + + MODEL_PATH = stella_models.get_model_path() + + # 1) Download & clean the light curve + lc = search_lightcurve(target='tic62124646', mission='TESS', sector=13, exptime=120).download().PDCSAP_FLUX + lc = lc.remove_nans().normalize() + lc = lc[lc.quality == 0] + + # 2) Predict with a single model (the pipeline also cleans LightCurve inputs internally) + t, f, e, preds = predict(MODEL_PATH, lc) + + # 3) Turn predictions into flare candidates + from stella.mark_flares import FitFlares + fit = FitFlares(id=np.array([lc.targetid]), time=np.array([t]), flux=np.array([f]), + flux_err=np.array([e]), predictions=np.array([preds])) + fit.identify_flare_peaks(threshold=0.5) + + # 4) Filter out obvious false positives (e.g., ultra-short fits) + filtered = remove_false_positives(fit.flare_table, min_duration_min=4.0) + print(filtered[:5]) + + Ensembling (optional) + --------------------- + + You can average several models for smoother predictions: + + .. code-block:: python + + from stella import models as stella_models + MODELS = stella_models.list_model_paths() + + t, f, e, agg, per_model = predict_ensemble(MODELS, lc, aggregate='mean') + _, flare_tab = mark_flares_from_preds(lc.targetid, t, f, e, agg, threshold=0.5) + flare_tab = remove_false_positives(flare_tab, min_duration_min=4.0) + print(flare_tab[:5]) + + Tips + ---- + + - Passing a LightCurve to ``predict`` or ``predict_ensemble`` is convenient: the pipeline will automatically call ``remove_nans().normalize()`` and filter to ``quality == 0``. + - If you have arrays already, pass ``(times, flux, flux_err)`` directly. + - Tweak ``threshold`` and ``min_duration_min`` to match your science use case. diff --git a/docs/getting_started/shortest_demo.ipynb b/docs/getting_started/shortest_demo.ipynb index b04c573..5890489 100644 --- a/docs/getting_started/shortest_demo.ipynb +++ b/docs/getting_started/shortest_demo.ipynb @@ -1,5 +1,17 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Backend note\n", + "Before running, select a Keras backend in your shell and restart the kernel:\n", + "- JAX (default): `export KERAS_BACKEND=jax` and `pip install -r requirements-jax.txt`\n", + "- PyTorch: `export KERAS_BACKEND=torch` and `pip install -r requirements-torch.txt`\n", + "You can verify inside Python with:\n", + "`import keras; print(keras.backend.backend())`" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -18,18 +30,9 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: leap-second auto-update failed due to the following exception: ValueError(\"Malformed URL: '//anaconda3/lib/python3.7/site-packages/astropy/utils/iers/data/Leap_Second.dat'\") [astropy.time.core]\n" - ] - } - ], + "outputs": [], "source": [ "import os, sys\n", - "sys.path.insert(1, '/Users/arcticfox/Documents/GitHub/stella/')\n", "import stella\n", "import numpy as np\n", "from tqdm import tqdm_notebook\n", @@ -61,43 +64,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Models have already been downloaded to ~/.stella/models\n" + "['/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0004_i0350_b0.73_savedmodel.keras', '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0005_i0350_b0.73_savedmodel.keras', '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0018_i0350_b0.73_savedmodel.keras', '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0028_i0350_b0.73_savedmodel.keras', '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0029_i0350_b0.73_savedmodel.keras', '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0038_i0350_b0.73_savedmodel.keras', '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0050_i0350_b0.73_savedmodel.keras', '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0077_i0350_b0.73_savedmodel.keras', '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0078_i0350_b0.73_savedmodel.keras', '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0080_i0350_b0.73_savedmodel.keras']\n" ] } ], "source": [ - "ds = stella.DownloadSets()\n", - "ds.download_models()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array(['/Users/arcticfox/.stella/models/hlsp_stella_tess_ensemblemodel_s004_tess_v0.1.0_cnn.h5',\n", - " '/Users/arcticfox/.stella/models/hlsp_stella_tess_ensemblemodel_s005_tess_v0.1.0_cnn.h5',\n", - " '/Users/arcticfox/.stella/models/hlsp_stella_tess_ensemblemodel_s018_tess_v0.1.0_cnn.h5',\n", - " '/Users/arcticfox/.stella/models/hlsp_stella_tess_ensemblemodel_s028_tess_v0.1.0_cnn.h5',\n", - " '/Users/arcticfox/.stella/models/hlsp_stella_tess_ensemblemodel_s029_tess_v0.1.0_cnn.h5',\n", - " '/Users/arcticfox/.stella/models/hlsp_stella_tess_ensemblemodel_s038_tess_v0.1.0_cnn.h5',\n", - " '/Users/arcticfox/.stella/models/hlsp_stella_tess_ensemblemodel_s050_tess_v0.1.0_cnn.h5',\n", - " '/Users/arcticfox/.stella/models/hlsp_stella_tess_ensemblemodel_s077_tess_v0.1.0_cnn.h5',\n", - " '/Users/arcticfox/.stella/models/hlsp_stella_tess_ensemblemodel_s078_tess_v0.1.0_cnn.h5',\n", - " '/Users/arcticfox/.stella/models/hlsp_stella_tess_ensemblemodel_s080_tess_v0.1.0_cnn.h5'],\n", - " dtype='" ] @@ -183,7 +151,7 @@ "#### create a lightkurve for a two minute target here for the example\n", "from lightkurve.search import search_lightcurve\n", "\n", - "lc = search_lightcurve(target='tic62124646', mission='TESS', sector=13, exptime=120)\n", + "lc = search_lightcurve(target='TIC 62124646', mission='TESS', sector=13, exptime=120)\n", "lc = lc.download().PDCSAP_FLUX\n", "lc.plot();" ] @@ -197,19 +165,48 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": {}, "outputs": [ { - "name": "stderr", + "data": { + "text/plain": [ + "['/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0004_i0350_b0.73_savedmodel.keras',\n", + " '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0005_i0350_b0.73_savedmodel.keras',\n", + " '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0018_i0350_b0.73_savedmodel.keras',\n", + " '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0028_i0350_b0.73_savedmodel.keras',\n", + " '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0029_i0350_b0.73_savedmodel.keras',\n", + " '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0038_i0350_b0.73_savedmodel.keras',\n", + " '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0050_i0350_b0.73_savedmodel.keras',\n", + " '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0077_i0350_b0.73_savedmodel.keras',\n", + " '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0078_i0350_b0.73_savedmodel.keras',\n", + " '/Users/benpope/opt/anaconda3/envs/stella/lib/python3.12/site-packages/stella/data/ensemble_s0080_i0350_b0.73_savedmodel.keras']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "models" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", "output_type": "stream", "text": [ - "100%|██████████| 1/1 [00:00<00:00, 1.23it/s]\n" + "\u001b[1m533/533\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 626us/step\n" ] } ], "source": [ - "cnn.predict(modelname=ds.models[0],\n", + "cnn.predict(modelname=models[0],\n", " times=lc.time.value, \n", " fluxes=lc.flux.value, \n", " errs=lc.flux_err.value)\n", @@ -225,42 +222,117 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"sequential\"\n", - "_________________________________________________________________\n", - "Layer (type) Output Shape Param # \n", - "=================================================================\n", - "conv1d (Conv1D) (None, 200, 16) 64 \n", - "_________________________________________________________________\n", - "max_pooling1d (MaxPooling1D) (None, 100, 16) 0 \n", - "_________________________________________________________________\n", - "dropout (Dropout) (None, 100, 16) 0 \n", - "_________________________________________________________________\n", - "conv1d_1 (Conv1D) (None, 100, 64) 3136 \n", - "_________________________________________________________________\n", - "max_pooling1d_1 (MaxPooling1 (None, 50, 64) 0 \n", - "_________________________________________________________________\n", - "dropout_1 (Dropout) (None, 50, 64) 0 \n", - "_________________________________________________________________\n", - "flatten (Flatten) (None, 3200) 0 \n", - "_________________________________________________________________\n", - "dense (Dense) (None, 32) 102432 \n", - "_________________________________________________________________\n", - "dropout_2 (Dropout) (None, 32) 0 \n", - "_________________________________________________________________\n", - "dense_1 (Dense) (None, 1) 33 \n", - "=================================================================\n", - "Total params: 105,665\n", - "Trainable params: 105,665\n", - "Non-trainable params: 0\n", - "_________________________________________________________________\n" - ] + "data": { + "text/html": [ + "
Model: \"stella_cnn\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"stella_cnn\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv1d (Conv1D)                 │ (None, 200, 16)        │           128 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling1d (MaxPooling1D)    │ (None, 100, 16)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout (Dropout)               │ (None, 100, 16)        │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv1d_1 (Conv1D)               │ (None, 100, 64)        │         3,136 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling1d_1 (MaxPooling1D)  │ (None, 50, 64)         │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_1 (Dropout)             │ (None, 50, 64)         │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (Flatten)               │ (None, 3200)           │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (Dense)                   │ (None, 32)             │       102,432 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_2 (Dropout)             │ (None, 32)             │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_1 (Dense)                 │ (None, 1)              │            33 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ conv1d (\u001b[38;5;33mConv1D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m200\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m128\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling1d (\u001b[38;5;33mMaxPooling1D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m100\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dropout (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m100\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ conv1d_1 (\u001b[38;5;33mConv1D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m100\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m3,136\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ max_pooling1d_1 (\u001b[38;5;33mMaxPooling1D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m50\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dropout_1 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m50\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m3200\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m102,432\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dropout_2 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m33\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 105,729 (413.00 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m105,729\u001b[0m (413.00 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 105,729 (413.00 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m105,729\u001b[0m (413.00 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -276,19 +348,17 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -299,7 +369,8 @@ "plt.colorbar(label='Probability of Flare')\n", "plt.xlabel('Time [BJD-2457000]')\n", "plt.ylabel('Normalized Flux')\n", - "plt.title('TIC {}'.format(lc.targetid));" + "plt.title('TIC {}'.format(lc.targetid))\n", + "plt.show();" ] }, { @@ -311,30 +382,30 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "100%|██████████| 1/1 [00:00<00:00, 1.29it/s]\n", - "100%|██████████| 1/1 [00:00<00:00, 1.33it/s]\n", - "100%|██████████| 1/1 [00:00<00:00, 1.35it/s]\n", - "100%|██████████| 1/1 [00:00<00:00, 1.34it/s]\n", - "100%|██████████| 1/1 [00:00<00:00, 1.36it/s]\n", - "100%|██████████| 1/1 [00:00<00:00, 1.33it/s]\n", - "100%|██████████| 1/1 [00:00<00:00, 1.34it/s]\n", - "100%|██████████| 1/1 [00:00<00:00, 1.34it/s]\n", - "100%|██████████| 1/1 [00:00<00:00, 1.34it/s]\n", - "100%|██████████| 1/1 [00:00<00:00, 1.32it/s]\n" + "\u001b[1m533/533\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 694us/step\n", + "\u001b[1m533/533\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 677us/step\n", + "\u001b[1m533/533\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 583us/step\n", + "\u001b[1m533/533\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 612us/step\n", + "\u001b[1m533/533\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 577us/step\n", + "\u001b[1m533/533\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 584us/step\n", + "\u001b[1m533/533\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 586us/step\n", + "\u001b[1m533/533\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 766us/step\n", + "\u001b[1m533/533\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 622us/step\n", + "\u001b[1m533/533\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 646us/step\n" ] } ], "source": [ - "preds = np.zeros((len(ds.models),len(cnn.predictions[0])))\n", + "preds = np.zeros((len(models),len(cnn.predictions[0])))\n", "\n", - "for i, model in enumerate(ds.models):\n", + "for i, model in enumerate(models):\n", " cnn.predict(modelname=model,\n", " times=lc.time.value,\n", " fluxes=lc.flux.value,\n", @@ -346,19 +417,17 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -380,7 +449,9 @@ "ax1.set_title('Averaged Predictions')\n", "ax2.set_title('Single Model Predictions')\n", "\n", - "plt.subplots_adjust(hspace=0.4);" + "plt.subplots_adjust(hspace=0.4)\n", + "\n", + "plt.show();" ] }, { @@ -392,29 +463,17 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "(1661.0, 1665.0)" + "
" ] }, - "execution_count": 17, "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, "output_type": "display_data" } ], @@ -430,13 +489,21 @@ "ax2.plot(cnn.predict_time[0], avg_pred, 'orange')\n", "ax1.set_title('Black = Single Model; Orange = Averaged Models')\n", "\n", - "plt.xlim(1661,1665)" + "plt.xlim(1661,1665)\n", + "plt.show();" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "stella", "language": "python", "name": "python3" }, @@ -450,7 +517,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.12.12" } }, "nbformat": 4, diff --git a/docs/getting_started/shortest_demo.md b/docs/getting_started/shortest_demo.md new file mode 100644 index 0000000..f152601 --- /dev/null +++ b/docs/getting_started/shortest_demo.md @@ -0,0 +1,119 @@ +# Shortest Demo + +This is the quickest way to run `stella` on a TESS two‑minute light curve using a prepackaged model. + +Backend +------- +Select a backend before importing `keras`: + +```bash +export KERAS_BACKEND=jax # or torch +``` + +Imports +------- + +```python +import numpy as np +import matplotlib.pyplot as plt +from tqdm.auto import tqdm + +import stella +from stella.neural_network import ConvNN +from stella import models as sm +from lightkurve.search import search_lightcurve +``` + +List packaged models +-------------------- + +```python +models = sm.models # list of installed model filenames +print(models) +``` + +Download a light curve +---------------------- + +```python +lc = search_lightcurve(target='TIC 62124646', mission='TESS', sector=13, exptime=120).download().PDCSAP_FLUX +lc = lc.remove_nans().normalize() +``` + +Predict with a single model +--------------------------- + +```python +cnn = ConvNN(output_dir='./results') +cnn.predict( + modelname=models[0], + times=lc.time.value, + fluxes=lc.flux.value, + errs=(lc.flux_err.value if getattr(lc, 'flux_err', None) is not None else np.zeros_like(lc.time.value)), +) +single_pred = cnn.predictions[0] +``` + +Plot +---- + +```python +plt.figure(figsize=(14,4)) +plt.scatter(cnn.predict_time[0], cnn.predict_flux[0], c=single_pred, vmin=0, vmax=1) +plt.colorbar(label='Probability of Flare') +plt.xlabel('Time [BJD-2457000]') +plt.ylabel('Normalized Flux') +plt.title(f'TIC {lc.targetid}') +plt.show() +``` + +Ensemble (average multiple models) +---------------------------------- + +```python +preds = np.zeros((len(models), len(cnn.predictions[0]))) +for i, model in enumerate(models): + cnn.predict( + modelname=model, + times=lc.time.value, + fluxes=lc.flux.value, + errs=(lc.flux_err.value if getattr(lc, 'flux_err', None) is not None else np.zeros_like(lc.time.value)), + verbose=False, + ) + preds[i] = cnn.predictions[0] + +avg_pred = np.nanmedian(preds, axis=0) +``` + +Compare single vs averaged +-------------------------- + +```python +fig, (ax1, ax2) = plt.subplots(figsize=(14,8), nrows=2, sharex=True, sharey=True) +im = ax1.scatter(cnn.predict_time[0], cnn.predict_flux[0], c=avg_pred, vmin=0, vmax=1) +ax2.scatter(cnn.predict_time[0], cnn.predict_flux[0], c=single_pred, vmin=0, vmax=1) +ax2.set_xlabel('Time [BJD-2457000]') +ax2.set_ylabel('Normalized Flux') +fig.subplots_adjust(right=0.8) +cbar_ax = fig.add_axes([0.81, 0.15, 0.02, 0.7]) +fig.colorbar(im, cax=cbar_ax, label='Probability') +ax1.set_title('Averaged Predictions') +ax2.set_title('Single Model Predictions') +plt.subplots_adjust(hspace=0.4) +plt.show() +``` + +Zoomed comparison +----------------- + +```python +fig, (ax1, ax2) = plt.subplots(figsize=(14,8), nrows=2, sharex=True) +ax1.scatter(cnn.predict_time[0], cnn.predict_flux[0], c=avg_pred, vmin=0, vmax=1, cmap='Oranges_r', s=6) +ax1.scatter(cnn.predict_time[0], cnn.predict_flux[0]-0.03, c=single_pred, vmin=0, vmax=1, cmap='Greys_r', s=6) +ax1.set_ylim(0.93,1.05) +ax2.plot(cnn.predict_time[0], single_pred, 'k') +ax2.plot(cnn.predict_time[0], avg_pred, 'orange') +ax1.set_title('Black = Single Model; Orange = Averaged Models') +plt.xlim(1661,1665) +plt.show() +``` diff --git a/docs/getting_started/tutorial.ipynb b/docs/getting_started/tutorial.ipynb index f7b1bb6..e89b14d 100644 --- a/docs/getting_started/tutorial.ipynb +++ b/docs/getting_started/tutorial.ipynb @@ -16,18 +16,17 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import os, sys\n", - "sys.path.insert(1, '/Users/arcticfox/Documents/GitHub/stella/')\n", "import stella\n", "import numpy as np\n", "from tqdm import tqdm_notebook\n", "import matplotlib.pyplot as plt\n", "\n", - "plt.rcParams['font.size'] = 20" + "plt.rcParams['font.size'] = 20\n" ] }, { @@ -112,7 +111,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "First, we need to do a bit of pre-processing of our light curves. The details of this can be found in Feinstein et al. (submitted). The pre-processing is necessary to reformat the light curves such that the Tensorflow modules work. The recommended settings (such as the length of light curve fed into the neural network and the fractional balance of non-flare to flare examples) are the default in the `stella.FlareDataSet()` class. The only variables you must input is the directory to where you are storing the light curves and the catalog.\n", + "First, we need to do a bit of pre-processing of our light curves. The details of this can be found in Feinstein et al. (submitted). The pre-processing is necessary to reformat the light curves such that the Keras (JAX backend) modules work. The recommended settings (such as the length of light curve fed into the neural network and the fractional balance of non-flare to flare examples) are the default in the `stella.FlareDataSet()` class. The only variables you must input is the directory to where you are storing the light curves and the catalog.\n", "\n", "Other variables that can be set are:\n", "\n", @@ -145,37 +144,15 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Reading in training set files.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 865/865 [00:01<00:00, 434.38it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "5389 positive classes (flare)\n", - "17684 negative classes (no flare)\n", - "30.0% class imbalance\n", - "\n" - ] - } - ], + "outputs": [], "source": [ - "ds = stella.FlareDataSet(fn_dir='/Users/arcticfox/Documents/flares/lc/unlabeled',\n", - " catalog='/Users/arcticfox/Documents/flares/lc/unlabeled/catalog_per_flare_final.csv')" + "# Set these to your local dataset paths\n", + "FN_DIR = \"./data/unlabeled\"\n", + "CATALOG = \"./data/unlabeled/catalog_per_flare_final.csv\"\n", + "ds = stella.FlareDataSet(fn_dir=FN_DIR,\n", + " catalog=CATALOG)\n" ] }, { @@ -201,7 +178,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -249,11 +226,11 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "OUT_DIR = '/Users/arcticfox/Desktop/results/'" + "OUT_DIR = './results'\n" ] }, { @@ -281,7 +258,7 @@ "\n", "However, if you pass in a list of seeds, then this function will train len(seeds) many models over the same number of epochs. This is useful for $\\textit{ensembling}$, or running a bunch of models and averaging the predicted values over them. \n", "\n", - "The models you create will automatically be saved to your output directory in the following file format: 'ensemble_s{0:04d}_i{1:04d}_b{2}.h5'.format(seed, epochs, frac_balance)\n", + "The models you create will automatically be saved to your output directory in the following file format: 'ensemble_s{0:04d}_i{1:04d}_b{2}.keras'.format(seed, epochs, frac_balance)\n", "\n", "For this tutorial, we will train the CNN for 50 epochs, however we generally recommend training for $\\textbf{at least 300 epochs}$ or until signs of overfitting are seen in the metrics. More information on that below." ] @@ -921,7 +898,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo0AAAEoCAYAAAA9lMuNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOydd5gkRdnAf1W7ezkSzibnBkTiAZLhwDlQQRAZJSoKiAoCghIVDhAF/ZSkKFEQ9ANGAVEBGUkSJH6AIAdNPGIDdxwXdm9j1ffHW3M7Oztxd8KG+j1PP7Pb0131dk9319tvvUFZa/F4PB6Px+PxeIqhGy2Ax+PxeDwej2fo45VGj8fj8Xg8Hk9JvNLo8Xg8Ho/H4ymJVxo9Ho/H4/F4PCXxSqPH4/F4PB6PpyReafR4PB6Px+PxlMQrjR6Px+PxeDyeknil0ePxeDwej2cAKKUOUEpdqpR6UCm1WClllVI3DLCt1ZVS1yil3lVKdSil3lBKXaSUml5tuQdKc6MF8Hg8Ho/H4xmm/BDYHFgKvA1sNJBGlFLrAY8AM4C/AC8C2wLHA3sppXa01i6oisSDwFsaPR6Px+PxeAbG94AQmAJ8exDtXIYojMdZa/ez1p5qrd0duBDYEDhv0JJWAeXLCHo8Ho/H4/EMDqXUbsB9wB+stYdWsN96wCvAG8B61lqT9d1k4D1AATOsta3VlLlSvKXR4/F4PB6Pp3HMcp93ZyuMANbaJcDDwARgu3oLlov3aawTSilv0vV4PB7PqMNaq+rRTx3G2bOttXNq0O6G7jMq8P3LwGxkGvyeGvRfNt7S6PF4PB6Px9M4prrPRQW+z6yfVgdZiuItjXWmXm9cHo/H4/E0kkbNsHW9t17JbVpWebUOkow8vNLo8Xg8Ho9nxNDT1y2wKEPEkJOxJE4t8H1m/cd1kKUoXmn0eDwej8czYjAMuxCCl9xnWOD7DdxnIZ/HuuGVRo/H4/F4PCMGQ/mWxiHCfe5ztlJK50m5syPQBjzaCOGy8YEwHo/H4/F4Rgxd1pRcGoFSqkUptZHLy7gca+2rwN3A2sAxObudDUwErm90jkbwyb3rRsYheIj4T3g8Ho/HU1PqPe5l+pv/zmolt11ptXeAwcumlNoP2M/9GwB7Aq8BD7p1862133fbrg28Dsyz1q6d005uGcG5wKeRHI4RsIMvI+hodMFvpdQnlVI3K6U+UEq1K6VeUkqdrZQaP/Cj8ng8Ho/HU28MtuRSRbYAvuaWPd26dbPWHVBOI87auDVwLaIsngSsB1wMbDcUFEYYIpZGpdQz9C/4XVEZHtdOoYLfsxBH034Fv5VSnwbuBVqAPwFvAbsjP97DwB7W2o4BH1xvPzV54zJxOB6Y/NCdk2dMW6ln8qe2aXsUWA3J59QKWOBDHUStJg5XBLYHOpG3mFZgTdfUczqIekwcTgfWABYAk4GFOojed31NAFYEVkbO03igB4nomgDM10FkTRxORX6Dt10bAVIGqQNo0kG00MShcu0s0UG0LOt4VnR/NiM+HOOA1d3f7yP1PVcB5rltFgKTnLzT3LFNBVZFEqb+G3gHMe/3AN3AdORmfNWdm7Y851W7c9Pl+l3T7d/sltd0EHUV+V3GAp9y+78FjHEyrAv8x33OBRa7c9XujvNtd17XR95We9yxWWAld67HAJ9wx9Hh2ugAtgKec332AB+6NmcA7wJjXT/j3DnrcG28g0TvTXF9d7u/X0Z+V4X8htPcsUx2+4xFro9OE4djXFvzs2RdrIOo3Z3LAGhy/YzFXStZ52uc63O+a399J/9KWcdogCXAMmAFt2uXOyfKbbsQ2DLrd1uig2hxod/J9Z3Zd313jB8h19ti5Dqah7xgfwSsA8Tu//nu/3WAN4GNkevvVR1EL7t7c1X3W33k9lsB+e3fQa7T/yL34crud5ru2h6DWBcmIvcOiDP8InqvAet+q8x9sKmTeT7wSSfLAndsxp2PN10fS3QQLXP39PZunx7ECjLJ/b0i8iyZ587nYh1EfaI33b2udRAtzFo3GRijg2iBicMVkOsNJ2snYHUQFcpH1wcThwGwmWvjYSf7Gu44Ix1ES0wcroaMGW3uOD9w36/ozs0yd/53RO69NieLcr/BQvf3Osi1ucSd98zf4915eBN5Zkx156jLyfWCa29N5LnyHvC2k20aMrZ0AYuyno9run5Xde0/pIOoxx3zJ5B74FUn/wbuuD9ycrUAmyD34kOu78y10+PO8WJgGyfnc+44ety+Y9w56UDu3y7X72pOnv/oIBr0mAeNszS+9/YqJbddZXW5rfzsX2UMFaVxFjJYvgLsygBqN7p2/oFkTT/OWntp1vpfIkXFL7fWfitrfRNyQ20M7Gutvd2t18DNwJeA06y15w/i8DJ9Ve3mcQ/lnwFHWEOLtaA0mB748L0WJk/rZuLkPr+rRR5aYwbRbQfyEC1EF6KYWMQvIx+ZQe5DZPAcl/Xdh8jDfHVEuaiEHuShD4Wt5zZrm3x0Ig/7dxEFZ50SfRqkwPxxOcpPM3LtfLG02GXTTq/COobix5Gh1PFWA4sMPs8jCrJGfl9D77X2EKKUTMzarwepsXok8pJ3IfB1t38TxQP0LL3Hljk+g1x/zfS/dizwAHCIDqJ3s78wcbgd8FNEmWgpfbh9MFRvpqaHyq/5wdDtljZ6le9yMcD9wI+BOUhZM4UoY/8DnIMoxZl7It9v2QM8BnxVB1HeZHkmDjdDlMRJZchTtRkza+U5Oi8ay6prdzJuwqDGx6XIS5dGzkfGH63QMb2NvBBnroV6XBfLgKuBw3Pkugv4QrEX43JolNL4ThlK42peaRwQQ0JpzKaeBb+VUrsjJXn+Za3dNae9dZE3vXnAOnaQJ6paN4+zijwGzLQWrfK0Zi3kW++pCWfqIDo384+Jw2sQBchTmjbg78DnkcG1VljEarthljXna8Bv6fvi4ikfiyhsTVn/V/LUMciL4to6iNr7fCHWz4+pXJGvGp0dcO0Fq7D97MVsul3DYw8axf/qIDp4MA00Sml88+2g5LZrrh4DXmmslCHh01glBlLwe3f3eVduY9ba15DpobWQN+d+KKXmOP/Lkssgjy2bnZCpp7wKo8hVxd48pTgl84ebYj2sgbIMN8YgFtlaKozQO72+Byz/nS7FK4yDQdHXClbpU0cjv/v+eb47igYqjABjxsIB3/qQs762Dp0do/aB+mUTh6UsvUOSLlt68QyMkaQ0llPwG/omzxzIPo1mU3x+zaHEROezB73+aJ7yaKb2U+gZmuh1m9gUhl/23xHIBPK7smxaZznyMm2lbqy1PPPQ4PQma6FtqWaITeqVQ8bvfNjRgyq5eAbGSBrgBlLwe9gUCc/iJcR/yzM0+EAHUcay/QHiG+kpn3o9vQ3wf+7vj2iwJcsDiHvC/+VZ/896C5KPd14bCyg6OwY+TL796hgO334jzjt6Ldpbh91w240EbA07jC29eAbGsLuKhxLW2jnWWlXOUsVu70Oi+Hryvbk2+G12tN2KlqxErM5f7vTGiTMsMYjyUEu6gUd0ED0J4IIvnnfrPY2hA5nJuTvPdykkmrthdLTD5XNWpbtbseVOSwbURnc3fG/f9YnfHMtT90/mzZfH0tE+rCxcc3QQDcuXYG9prB0jSWkcSMHvYVMkPIOzau0K/FkpekwPdHVCR7uivU0VUxpfKvhNeXSRf5C1SHTvAuBG4Ab3fz5JMtstgX51nrqR9DiLXV9dyMCS3U4xpbQViQTMR4/ru6PAMZSiM0/fHwIH6CD6U/ZKHUQXAt8qIks+2cjTfvb3zwFPIik6lhTZNoNFjnWwylipc9UNPA2c5z4/QoK0HnJ/v4Ao0cXOxTK3/3/dPq/Te07y0YlEuHfRG0ndVqSPRa79vTMrXMqTR1w/pkR/2diszzbktyi1bSl6kKjZepWoaEfkfhG4cwD9Zs55vvVYC4/fM5kff3NNzjlyLR6+c4o1vT0Y5Lr8ELgE2DXLSr8c9/K1Hr3uQdXGINfL8t/TWujpge4ueG3uWOYcvg7PPjKJY857m4lTyjpFueek8+rzVlncurjJdaD4wQHrceuVK7Hg/Wa6+88VZc5N9j33DhKBXUteRBJTP0nvMbQDJ+gg+mmN+64ZXmmsHSMpevpI4ErgCmvt0Xm+z6Tj+Yy19h637sfAGcDp1tp+N4hS6iXEn3F9l3hzwNQiisz50mkdRN1Z604DzkQGo8wDfm8dRP8qo70WJDXK0UiS0jeRh/tcoCPfA75IW19AUjmMR/zJHge+rIPofRcBvhWSP24CcDCST3Mh8Evg+uw0NjntfgL5HY92bXwIXAD8xuVA2wL4A+Kv2oNE5349Ny+cicNMSqXcF6duJNL2auDXOogGFTpp4nBVYAdEWW6iNxegBm7TQfRCzvYKSQEzDrGODUrxc+1NAdp0EHW5vHkBkmeyvfjeYOJwfUTpmoVMv18A3A60Zl93Jdp4DknJk48OYEaxXIomDj+JpCL5v+x8gDnbjAVORoIoxiI5V8/SQTQ/Z7vxyJTo2vQGwrQDt+ggOqSc4ykHl7fyEODXyD2Qy/M6iIr67pk4/CFwFv19mNuB05CXrH9T3hR/G/B9HUS/KdDXeUgy4dy0WnOR+2gt5DiWIc8IS28gTAcy3a8vOnk17rtlOu1t8lVzi+kcP9Hcte835u/3tf95sOLBxqVFOhHJa/gP4FIdRPNdgMalwEHI+XkeOFoH0WNZ+zYBP0de4jL5LC8BTs99lpk4vN4YDl74YbOePLUHY6GzXTFlumkDttVB9F937ayApAW7h75ppEAUvCN1EN0E8OVgvycXftAyM/eYJkzu4QcXv8kOey2mu5vuI3ba6D/xm2NfX2nVzt/84cm57wDv6SBaZOJwCpBw5/puJHfwmUjexmeQzA1PmzhcC1Gwc10uLPBXHUT7urFiByStziNIns6aD/6Nip5+at4aJbedudZbgI+erpSKlUal1D7Iw3BjYKK1dn23fmNgH0TZG7AfhE+5M3hcktbPINa3OwareAyg/08hFqfsqNguxPK0ZeZhZeJwJeRhvwK9D7xW4HIdRCcNoF+F5JDbht6BugP5HbfIzjlm4nAD4AknYwu9OQcP0UF0W5E+NkEUjmd1EL1dqYwl5N8FuAoZoAFuQQbCosmphzomDk9E8vrlKk8WOF8HUd2m9E0cfh1RHHKjG9qBTXUQvVLFvtZFru98SuMTOoi2LbH/p5CXrdz924FP6iB63cTh/cAulFYcFwNr5SbnzuprPpIMO5cet2TneO1GXoKmOln+Dez82gvjJp2wzwZ0LOs3gdUKfCZtUo+WkLFiXF7UluwCAXm2mYQoem8Vegk0cbgjUvYt9zwuBabk5GI9FlFG80XfX6yD6ASA2U0HnN7cYn/c1an7tNky1nDNgy8yZYVue9vVK/X87qerNtP7/Dk2bVK/M3F4AHAdvZbHJuBgHUS3F5D/LmA3+ir9bcBsHUQP59unHjRKaXx83lqlNmXbteYBXmmslLKnp5VwHXAbkESmD7ITIC8EfgJUlJC7Uqpc8PsB5E16F6XUF7L60IhFBeC3g1UY640Oond0EF2ng+hPtVIYTRwqE4fZkcPZHEd/i0ULYmXbImvdMcjAk/2GPBH4jonDGQMQayfE+pg9yI5FKkjsl72hDqKXnSxXIwP77cAehRRGE4fTTBw+jAzifwBeNnF4VYHjrxgThyEyXbgBMkBn0tEUVGCHEb9GXiLa6LV+GyQR9BnV6sTEYbOJw31NHJ5v4vAYV90olz3In1y5C0lCXjV0EL2GvLDkWuhbgbwWv5z9n0eUkzZ6qxktQyyor7vNjkWmmzMVPDpc+y8jCt0y9/esQgqjo1CIcBP9iwI0IwrmFB1E04FfAPapBybTk9/2PJ7e8mpVRQdRdzGF0W2zVAfRiyVmDTam9xxmo+h/XbxJ/mDENmSWAgBr1W+7u9R8pXvHjzFjjdlm1uL3F3/cFJ171NrdTmHM9DMBuHjunZuvC/ze/T/FLROBG4s8F7+MpI7L/P4fIVbPhimMjcRYVXLxDIxKUrd8B8lBdw0yjfE94EeZL621sVLqYSRR7wV5WyhAnoLfANsrpa51fy8v+I2Uc5qLWADXziPjI8AlSqk96F/wu88AZa3tUUp9HSkj+Cel1J+QB8Ie9JYRvLCSYxkNmDg8DKlIsxKwxMThT4BfZL2Nr03+SgbdSJmqp93/s8j/tt6BlJVMVyjaTPJHxU5GroNU9kodRG8A3y6z7WuQayJ7AD0IqYRxSYVy5uME+g/OY4HtTBxuqINosD6pDUMHUYeJw92R33sHxCcxpYNoYBEGeTBxOBF5CdwQUYDagJ+YOJylgyg7QvcNxC8yX3Wkd/OsGyxfdHJNQu4JDfwZsSKVRAfRWSYO/4y4UhjgZh1Ec7O+f95N3x+LXP9PIW4Vb5s4XMP1Oa+MqcgHkKnQ3NG0WFWSzLb3AfMnTOqZ2NRidR5/vUxZu6HMTPI/ixRSxvCRrHV3Isczgb7JzbuRF0oA0ib1UUInt8RyDuJTu7izQ1/6yF3Tfv3IXdOeJv+zyuomjiW/QccidYwvy/3CzUbs59xPVgDeKOQ+YuJwZeR5sydSivAXOogeyrftcMX7LNaOSpTGI4BngaOstYUSVr/MwN4oMwW/s1mX3qTa84DvUwJr7atKqa0RC8ZewOeQaemLgbOttf38oay1jymltkGskbMRBWOea+P8atSdHkmYOPwSUkkjM/U8HSknBlJGDETZ24n+02pjEYfrDK+77XIHpRYGluphHjJA5Vo5+1gAysVNd+8CfMEtuXJOQKyq1VAaNyb//diJWPSXK41Orl2BryCKxA06iP5dBRlqhlNa7nVLLfg+Uo83M/Bnrs//NXG4UZbSdBX9FfRMfe/7qi2UDqJXnM9ZAvHLfLjSFwAdRP9BXk4Kff8O4uOYu/6tCro5AZlmHofcP51uuQd5jmYrOD3A/ZnIWh1ExsThbjvstfiWy+es1s+HD1F2bqxAlkYwF3lO5Caa70HcnrKxiHJ4AvJM6FnwfvO8X5++2oUP3zltDUh+lDYpC5A2qXeQsbMPCZ18n/z5KFumrthtyf8saKa/H2UfdBB9hFgZ83LrT3bYYMy4FZ7o6VITt91jcfOM1bu2AmabOPyODqKyXmSGAz12JMX4Di3K9mlUSrUitZtPdP+fBZxprW3K2uYnwInWWl9pIYd6+3bUChOHLyAKTi4fAyu6AWQqMuU7g97BuRX4rQ6i5cq/icPNkTf47Ad1J/CUDqIdBiDbGEQR/QR9LQCLgHVKTM/ltpWpP74n8qAu9Lt9qINoIFPpuf2dC/yA/gpvO7C+Uwwy2/4KqRU7gd7o9Yt1EJ1u4nBNJGJ5FmJFuGDPVTf/L6JgTkGCCR7LDGojBROHLyPuD7ksAzbWQTQva9s9gOuR89GERG5/KXubgZLQyUnIVOFayAvSHWmTKjc6u6G4oK1jkaC0Z5BAk6WIMhkgL9RL3bK9s9T34diZn/tK9MyEq6zFuFtGAwenTeqvdTmIAWLicBriSpAJUgOZgn4V2CQ7cMbE4R+BfXHPLWOwSz5uUkftutHiRQuamxDjyV5pk3q/UH8Jnfwc8nzJVgK7gCf+8e6z30X8K3MV2GXANjqI/lvgGFZDZgB3Ql4y/0cH0XNZfX62ucXc3jzGNlsD1igOPuF9Djr+AxDL6QwdRFU1kjTKp/H+1zcoue1u60hw/nAfk+tNJep4N6XLbq1G7VMEeBrLmgXWT8I95Fyk8lbIoPMKMngejShFy9FB9CyizLyPvOV3INaefQYimLN87Ag8Sq+l5Flg50oURsf+iLV6EoUVxh5kqqoa/ApRrLP939qAP+QojDOR2tYZRTZTju0EE4e7IYP9EUjU/x493fz1c4fOfx3xNz4TSZz8+4ROjrQHZSHFTOV+p4PoHiQwYiYQ6iDaeqAKo/Pr/ZaJw5ueSm11udL2TWRm40zgj8BTCZ2cXEY7a5s4vMLE4YsmDv9h4nBWqX2qjQ6id3UQna6D6DM6iL6vg2ieDqIFiAX3G8C5iB/yuvkURoBfPXXHTdaqlUB9GTgQmDHUFUYA93zYgd5UTF3A34BdchTGdcgpfak1atx4w+cPm5/xPdwEUQgLkjapO5AZmmXIS20b4razv3On+D3yPMj4AGcCBAspjOshL+rfRVxxDgEeNXGYAHDXYKq7Sze3tzbRsayJzg7N/17yCaJnx4PcJxvma3s40mmbSi6egVGJpfHfSNDCJm56uo+lUSk1DnnDetFam6iVwMOVEWRpfBIZbHP5AAgGksbBWfXWBha5QWrQuCCIptyUKxXsfys5wTM5ZPLdzaxwGrBYn+sAP0XcJBYj094Xu7x1mW3mIL7EuS98HYjCOJOcqa2lizVf2XQTuruW77IUOCRtUnkjMYcjJg5/gAzC2dYZg6S22bxGfa6IRODPACYes+cG9tXnx6ucW7wduChtUv2mj7PaWRdJAzSR3t+uDYmcv6EWso8UEjqpAVVNa65L32Sysy1kfbcv4o/aL7fvE/dO5oeHZjyqaAfWTZvUe8X6SujkFMQ96/20SeW6oOyOKH8GyX/7QPbzNaGTLYhfdXLLnZdsdtDx76+2+Q6tudrQ68B6e666eRJJSTcl+0utDft8fQHfOffdfjMa1aBRlsa7Xss3GdaXvdYV1+DhPibXm0p8Gq9HrCEXKqVOzP5CKdWE5NdbFTi1euJ5hiCnAH+lr79iG3DKQPN+uTf5in0OS7SZN59fBRQq1diJvNH/BckN+eEg+1mOi4g9sMRmbYjVPzeQI5MQud89rTWsslYnb72yfKJgEhLUNmKURsS6l0CsRS2IEr0MmSquFWcgsytjFi1o4o0Xx+UqjCCzM4eRx+cwizn0BspkmABcbOLwxnLzYY4mEjq5IhIQ8kVAJ3TyAeDotEkNOmVSiSnaV8kTwNLZCW++3MezpAdRLIsqjWmTWgz0y6HrnqX3uKUfTmG8B5nRmfjMQ5N44ckJHHz8Bxx43AfZm66GRLq3kGfGxBhF5zLdA/y72gpjI+kZUXVLhhaVnNnLkZQ2xyG+UgcBuIjjeUgC1duttX8o2IJn2OOm9vZBLCPLEN+Zw3UQXdtIuWrA75ApoVzaEH+uc6qpMFbATeSfilUUULybWyyLPuqnS9arAkldcK4JeyJW2tOAI5G8hLWMOt8fp7wrRbFMiaVepnYjf4TyWAq7g4xanHXxAWQmoAU5d7sBjyZ0slB1r6rg0iA9TU56np4uzV+uWSl7VRu1q2gDEk2/Jc4n0lpFx7ImbrjwE3w8v8+9npnavps8yu64CYZtdl/8ApJGb8TQY3XJxTMwyj5z1toeJG3AOcjDLEQek/sjb8XnMsIuPE9+dBDdo4Nopg6iCTqINtJBlCq917DjLiTNzjJkqikTALCfbmA9Vud7900n1xK3tCFVdc4lp3RgZ4fiiXsms7iv0tgKXFtLOV0ez2+ZOHzZxOFCE4d/MXG4US371EFkdRA9ooPolzqIbtZlVLwZJMtfKqas0MN6n1yG0v30w3ZKp9eJC6xvpkgk7ChmFqJMZ1vbNWLVrVpVnyJ8Hsmf2mkt3W+9Mrbr9IPW7Xj/rbEgL3RtwJE1DoDalzy5NZtbLM8+sjy2ph34kw6iZWmT+hA4HnludIG1SttlLWPtLeccuc7m1XILGioYdMnFMzAqOnPW2m5r7RxgZSSCdickbcDK1tqzrLV+GsUzInAKyHHI9M8pSFTpajqIHmisZOD83FZHrPtHAavoILpNB9HfEPeQpbiEz4sWND/y8xPWbEMUnE5kQLseUYpryQVI0udM2cS9gced3+ZI4TKylPRTfv0mU1foZuw4k0nEvRRJlfOTEu2cT/864e2IYhKYOPyricNFJg7nmTg8oVoJ5YcxIfktsxMpXK6yauggWqSD6EBgilKseOQuG8144cmJmSCza4Dt6uAv/BF5ZhwUMH6iaUWUwweQZwQAaZO6AnmenQ/qQmvUXksWNh8w0jIpAPRYVXLxDIxKAmHOBF631l5fW5FGJiMlEMYz9DFxOA6pLPOBDqL3nf/XlxAn+LvTJlUw51+V+p+G+HLlZlvoBq7SQVRuQvUhjattfC1ybrsB1bFMvXfMnuGFb70ybhoSJHNv2qRKugK4UovnIIrAWOAOJHXSY4hFKaMotgHX6CD6bpUPZ9iQ0MmdkfOTa2lrBU5Im9RV9ZeqviR0cguk+ESftDxK2QU3P/ffL09Zoef1rKpBDaNRgTA3vrx1yW0P3EBSBvsxuTIqURo7gYustSfXVqSRyWhUGk0cqvZl6timJk5pbrZTleZh4AfZucM8Iw8Th59G8kHm8y97VgfRFnnWD1tMHK6P1Dt/G3hooAFhJg4nIJbZWAfRByYOL0VSVeX6orUDaww0M8Bwx6WLegyp1JKJPulGMjiEaZMqVi5wxJDQySORDAuZoL1lSH7IZxonVV8apTT+4eWiZd0BOGSDx4HRNSZXg0qip98hJ1zf4ynGk/dPuvtT27Z+pmWMjKHWsCeKHU0cztRBFDVYvGGNs3LtiiQy/3ehvHkN4k36JykHCb4Zcb+7DqJX6F81ZCDttNG38st25C811wFsBIyo0m/lkjYpm9DJPZD0VIch49jfgBNHi8IIkDapqxI6eTPiJtYKPDRcEsnXGj/9XDsqURpvBb6glBpvrS1aIN7j+foG+xx0Wbr1M2PH9RpdlIaeHiY2NXE6UtHEMwBcXr/7kBKOAC0mDq8GvjtQK1c10UH0nonDO5Dyc9lT1O1UWJd+lPMiEiGb6783FslYMWpJm9QSxM/42EbL0kjSJrXYxOGjiO/iWSYO30Byuz7bWMkaiw90qR2VnNmzgIXAbUqpmjsbe4Y3U1fsPq27s//bXlMTqqeH7Rog0kjiL0ggzGS3jEOU8FI5HuvJoUh93nYkAGcecIAOoqcaKtXw4mfkpHZBpiD/Ua2E8p7hjYnDTyB5Y3+ERJV/FXjEJSEftfiUO7WjEkvjs0iKg62AZ5VS7YgPSa5lw1pr16uSfJ5hyruvj10hMy2djTHQ3qrn5Ztz85TGxOEGwLr0f+GbCHwH+N+6C5UHHUTLgCNNHB6DyLZwKFhBhxM6iJ6F/VMAACAASURBVJ4zcbgP8FtgHcRv7w9IrlwPyyunzERS8DxVjfrhw4zTkOTdmfRDTUhwzJUmDv+WXU1qNNHlywTWjEqURo043L6Zsz7XnOSdCTws/LDlvofumHrIDp9dpMaN79UVujoUpked1UDRhjsTKVxnecj5HLvqGsUqbHiKoIPoXiA0cTgFWJavtN1oxcThykjS6g2Qe2KMicMbgSOy60WPcPahf3UoEMVxPUagD3E5+IowtaNspdFau3YN5fCMPOb88sQ19mld3DR59lc+0k3Nlvlxi733z9MvPPT8hx5ttHDDmOeR6d5cliHVYjwjEB1EixstwxDkemAT+gYLJYEngV83RKL6U8ik1gQsqqcgQwnjA2FqRtkpdzyDYzSm3Eno5LrAGc0tZtfxE83brUuafvyPrj/9s9FyDXdMHH4euBkZLFuQyMk3kPKGSxoomsdTF0wcTkdygeaL0o90EG1YZ5HqjonDLZDUQ/ksjffpINq9ziL1o1Epdy6au0fJbU/YWMp6j6YxuRpUMj3t8VRE2qReA45otBwjDR1Ef3cDxjeBNZApuj/WoWyep84kdLIFOBGJjp2ABEH9KG1S7zdUsMYzgcI1vSfXU5AGciT5LY09wBV1lmVIYXygS82oWGlUSo1FEtmuRv63PKy1vx+kXB6Ppwg6iF4GftBoOYYSJg73Q1L6rIck2v6hK7k4nLkJ2JPeyh+HA59L6OTGLu3MaOVd4H1grZz1XYhiPRqYRn6lMbck5aijpwGhFUqp1ZGqTnshwUnvIaVAz7bWLqygnZ2QZ/vmQIAEHD8PXGKtrXX515JUpDQqpb6BpIGYXmgT5O3PK40ej6dumDj8AhJZnFGu1gIuN3HYooPod42TbOAkdHJjZAAan7W6BVEWvgb8qhFyDQV0EFkTh4cDf6fXTaMN8eM7u4Gi1ZPbgH3pX06xBbi3/uIMHeodPa2UWg94BJiBvLS8CGwLHA/spZTa0Vq7oIx2vo3UtG9FcmO/jaRX2x/4rFLqh9ba82pzFOVRtg1XKbUXcBWiPX8fURD/ApwBpN3/KeAb1RfT4/F4ivJTcurwuv9/0gBZqsVMJM1OLhOBHessy5BDB9H9SCnBXyEVYc4EPqmDKG6kXHXkNuBxRMEAMdi0AWfrIPqgYVINAYzVJZcqcxmiMB5nrd3PWnuqtXZ34EJgQ6CkoqeUakGeY+3ATGvtYdba06y1hwFbI1koznCzvQ2jEkvjScACYAdr7RKl1C+AZ6y15wPnK6WOQPKJXVoDOT0ej6cYhXLDfsLE4RgdRPkizoc6b5A/hVk78FJ9RRma6CB6FfH5HHXoIOo2cbgnEjGeBBYDV+ogerixkjWeeibvdlbG2cj9mhu1fxbie36YUuoka22xMpcrAFOB/1hr+9zf1tq5SqkI2BSxLDcsjVklSuNWwF+stdl+NMt/GWvt1UqpwxDL42erJJ/H4/GUwxvIG30uHyJ+bsORh5FKOiF908p0A1c2RKI6ktDJzYCDkHHqz2mT8qm6ctBB1I0k9C87qb9LiD4NaB2mL1MlMRX4NGYirsvkbGvtnJx1s9zn3dbaPvlBnYHtYUSp3A64p0jbHyDPq1AptYG19uUsGUMkH+kz5Uxz15JK1PGJyNR0hnb6JxN+Evj0YIXyeDyeCjmD/gEArcCZw7USTdqkLLA7MtB0umUu8Jm0Sb3TSNlqTUInTwYeRQICTgTuSejkxY2VqnaYOJxk4nBqHfr5PPKCFQOLTBz+1sThuOJ7DT/qXEYw87JaKJF6RvkLizViJf/hMYhe9pRS6jql1E+VUr8HngL+i1iUG0ollsYYWDnr//fo/2Y/lcLJRj0ej6cm6CD6s4nDFuB8pKRcDJylg2hYW+TSJvUB8NmETk4GxqVN6sNGy1RrEjq5JhLMkq3MTACOTOjkDWmTeiKhk+OQestHIlk8/gacnDapd2shk7POHQOcDKyEDOIn6SB6fJDtrgZcB+zi/n8W+JoOohcGJ3HevrZF8rtm+/5+FTH+HFzt/hpJnZN7Z5T9QsnUM+unlWrIWptSSr2LWI6/mvXV+8DvgNcqFU4ppZE0VHl1M2vtR5W0V4nS+F/6KokPAgcqpXa21j6olPoU8GW3ncfjaTAJndTA54DPA/OB69Im9UpjpaodOohuBG40cahHWhk5l16nrBQ7zmL1RUQZSOsgmltL2WrA3uTPwTgOOa4ngNuBneiNLP8KsHtCJzdKm1Qtquf8GDiBXoVrJ+A+E4fb6yD6z0AaNHHYDDyERMdmxuKZwEMmDtfVQfTxIGXO5TT6RuLj/v+iicMZIyl4ppLo6aGU3FspdSjienILcC7inrIW8oL0K2BXRM8qp60vAqcAW1JY17NFvstLJRvfCVyklFrVWvsuknonCdyvlPoIceJUyM3l8XgaSEInm5F0JDsgjtNdwEkJnTw8bVI3N1S4GjPSFMZKMHG4G/BX928zcL6Jw6uB44bRNH0nkO837AE6Ejq5BRI9nq0ANSNK8mFUuYSgicOJwPfor3BlrJ0DnTLcE8nnlz0OK8RyegjVL4UYkj+wqgNRXEeM0mjqW3s6Y0ks5F6QWV/0JcD5LV4D/Ac4LMs/8kUXL7IhkFRK7Watvb9EWwciKcgAngbeIn8mhoqp5MxejiT0ng9grX0B2ANRJucjVSk+a629oxqCeTyeQfEVZGDN5HBrQQa9axI6mZuaxjMCMHE4FsntNskt45Df/OtIvsfhwm3kH5u6gRuBLcivVE6kNj71a5F/wNXAdm7qeiCsS98ApwwTkKCHavMo+Y9jDDCiZiB6rCq5VJFMpHMhn8XMb1nI5zHDbOR6eCBPQI0B/uX+nVmGTKcBS4FtrbVbW2u/aK1N5lvKaKsPZSuN1toua+371trOrHWPWmv3ttZubK39rLX2H5UK4PF4asJByCCaSzewc51l8dSHXcj/TJ+IVJIZFqRNaj5iMVyGDHytSODl99Mm9RKFFZxlQNV9AYF3yKPcWQumh9WWteoF7z6xyS4DaPf/yK/ELUWm4KvNT5FzlG1xbgUu0kFUiyn9hmGsKrlUkfvc52znP7gcpdRk5OW9DVHai5HJv7hyge8z68uJeA+Bm6y1T5WxbUX4Ao0ez8hkWYH1ChmAPSOPYo5c+SxaQ5a0Sf0ZmTI9FvElXDdtUpe5rx8GXqfv4GkRF4xrqi2LDqJFSBBCn+h8pUA3ocZPNNOnTO+5/zff3rVQrtBCPIJMHWbfj51IENefBiNzPnQQvQJsD9yBTKm+gkSmn1HtvhpNPZN7W2tfRWZa10aCpbI5G3lpuz47R6NSaiOl1EY52z7oPg9QSm2W/YVSagvgAOQ6L6faz2J6k75XlYprT3s8noGR0MlJwD6I79XdaZN6vYbdXYXkS821NnYgg65n5PEv8iuOS+n1bxo2pE3qIySyOHe9TejkLCRgYG/kRehp4EgXbV4LjkN80k60lrEqx1CllFVTp/f8DhcFXQ6uFOKewA8RF4IWpKraj3QQ1SR5sw6i/yLnbETTVcfk3o7vIC8Blyil9kBSY30ayeEY0V8xzwSnLb+SrLWPK6V+h1wLTyilbkUCYdYG9kPcCC6y1pYTbHwnFVyLlaAkNVCeL5Qy5I9gK4W11nplNIdMAtGhFKnlqR8JndwZCUwBGdg1cGHapE6vUX8KuAD4LhJAYNznXmmTeqwWfXoaj4nD/YA/ItfXGMTacBfwlZEYIJTQybFAU9qkcnN01oTFL210zviJ5kdNOSOc6YEbL53Rduj5D+VzCRm11Hvcy/R31BNfLbUpV27ze6B6siml1gDOQfyHV0TSEt6KJARfmE/O3L6VUgqpK384sDmSKmcx8lJ0pbX2xjJl+QQyHX4rcJq1tmovIcWUxvsZmNKItXZW6a1GF15pHL24gS2mf56uVmCftEnd13+vqvW9DpIgehHw97RJFZq29owQTByugfi0TkcsDg8Oo8jpIc07j39q9rQVu/8xfmJf/XvZUs05R649/4L77yrkjzYqaZTSeMQTXyu57dXbiBF7JIzJSqnb86yeAWwDLER8ffNFb1tr7b6V9FXQImit3a2ShjweT0F2I7//8ATgCHodqauOmwK/ulbte4YeOojeQlKiearMKmt2pl94YsL8dTdZttK4CaKHt7cpXnhqgnn6wUnVTpHjGSBVjo4eDhRzOVgBySuaj4pfJv00ssdTe8YUWJ/JyebxeIYBOojsxafsveWWuyx5avcvfrwSwN03Tu++839X/Je16qeNls8jVDPQZZgwuV4dFVUalVK7AG9Ya9+stSBKqdXp7w9wG3n8AQrsvxvlWWzWtNa+lbVfMU37MWvtdmW06fEU437y32tLkXJRHo9nmHDlC397O6GTq9x6xYzdgXWAp9Mm9WSj5fL0Uucygg0nOzK71pSyNN6HhIyfk1mhlNoX2Nda+41qCaGUWg+JPJoB/AV4EdgWOB7YSym1o7V2QYlm3nCy5mNTYH/g+WyFMYt5wLV51r9dUniPpwRpk1qS0MmjkIjmZre0Av9EXow8nhFDQie3pDc9yM1pkxpQmb2hTNqkDHL/eoYg3aPP0tgHpdQlwB3W2ruKbDMb2Ntae1wlbZdSGvOp61sg0T1VUxqByxCF8Thr7aXLO1fql0j5pvOAbxVrwFr7BjAn33dKqYw158oCu79hrc27r8dTDdIm9ceETj6GFKGfhpR6uydtUlUJUHDVQDYCPnI+bR5P3Uno5LlI7r+M28WJCZ08L21S5zVQLM8oYxROT+dyLFKpr6DSiATJHIOkkyqbhvs0OivjbMRSmOtIfBbwTeAwpdRJAzHBKqVWQorcLwN+PzhpPZ6BkzapV5FruqqYOPwqcCnyktdi4vBx4AAdRB9Wuy+PpxAJndwEOIm+NZrHA2ckdPLmtEm93BjJPKON0TY9PUDGIGnYKqLhSiOS/BLg7jz1FpcopR5GlMrtgHsG0P7XkLfe31trCxUMn6aU+gYQIKlJnrLWlir5g1JqDjVQAjyecjFxuAPwGyQSO8P2wO3us9x2JgNfQBKPp131CI+nEvYlf+UZjVxbv6ivOH1x13gAvKWDqKZVkRI6uTbiXrUl8BRwcdqkah4b4BFM3knSUUfBWSylVBOwA1BxMvyhoDRu6D4LFfN+GVEaQwamNB7lPi8vss3m5KQlUUo9CxxmrX1uAH16PPXiRPpadkAG7s1MHIY6iArdV8sxcbgzUlrM4hKPmzj8NfADn9/PUwFdSBL5XDIl/hqCicMWxBL/NVytZxOHPwZ+Vovr2/l0/gsxVrQgL29HJXRyx7RJ+fGkDoxGS6NSKtd3+BilVDLPpk3AKsBUBpCOrZyJ/1oPGlPd56IC32fW5yZGLolSaldEKX3eWvtIgc1+iRQUXxkJW98Gqfu5OXCvUmq1Svv1eOrIGuT3Pe5CrCpFMXE4Bgk+m4Rc/xOAcYgP8WeqJ6ZnFPAn8iuNAH+upyA5/Aw4DLmuJ7nlR8ChNervMtdHxuo6xv1/cY368+RgrCq5jEBWRZTBVRC9bXLW/9lLJjvNr4HvV9pJOUrj95RSr2UWxORO9rqc5dVKhagh33SfVxTawFp7krX2EWvtfGvtUmvtk9baJPKQW4kiJ9VaO8daq8pZqntYHs9y7gLyTbWNAZ4pY/9dyV+veALVDXbzjHBcIvnjkeuxDckQ0A58K21S7zRCJmdl/CZ93TdAarLn1gMeNK5856fzfKWAnavdnyc/3UaXXEYa1tqVrLUrW2tXRq63CzL/5yyBtXYTa+1x1trFlfZTzvT0NPJb+dYuJHuFMmQsiVMLfJ9ZX8gfMS9KqRWALyEBMNdXKBPAb93+NSn67fEUIqGTLcBngbUQf6h/F4myvgRxwViR3iTibcC5OojKeSDk80EDeeiMK1tojwdIm9QVCZ38K7APMhbcnjap9xso0iQKj3MlLfEDpA1RSnNZUqP+PDl4n0b2obDL36AopTSuU4tOc3jJfYYFvt/AfVZ6AjIBMNcVCYApRiby1Beg99SNhE6uCTyEvKi1INFtTyR08rNpk+pnUdRBtMDE4ebAD4DPI47Nv9RB9Ncyu3yA/JbGVuAPAzgEzygnbVLvUWR2p858jKQeWTXPd00mDvfVQfSXanWWNimb0MmrEOtmtq/xMsQQ4akDI3T6uWystX+vVdtFlUZr7bxadZxFporLbKWUzo6gVkpNRvwN24CS0cw5ZAJgBvrwylSCeW2A+3sGiYnDSUg0b6yDqJCv1EjjBmSAy1bkPg2cQoHk9S61zsluqQgdRK0mDg9H0lE1IYpqKxJ0dmul7Xk8QwkdRNbE4XHI9Z07RT0J+KOJw8N1EKWq2O2pyEzcbKATMV78nQJ5hD3VZ7QrjUqp/cvd1lp7S0VtW9v44Eil1D+QG6xQcu/LrbXfylq/EYC19sUC7e2MRK89b63dtEi/mwFzrbVdedbfi0z5HWKt/eNAjy2rTetkHt1Xcxk4ZfFKJL+mBRYA367AejYsSejkdCAmf63qN9MmtVat+jZxuA4SLDANGeDu9ZHTnpGCicNZwN/orzgCzNNBtHa1+0zo5DrIDNqLaZOqhwFmyFHvcS/T3+73fq/ktvfufiEwMsdkpZShtKugAqy1Nt9MU0GGQsodgO8gZQQvUUrtAcxFrCuzkGnpXIflue6z0I9dMgDGcSKwj1LqQeAtoAOpqrEXYnW5El8buBHcBOxOb1WJ1YAbTRzuooPoqcaJVXOK3byFfA+rgg6i18kqF+rxjCR0EN3nMgXkYy0Th7rasxkuMOj1arbpKY+eERjoUiHfLbB+GpIhZh/gFnpnestmSCiN1tpXlVJbI4PWXsDnkJDwi4GzrbULy21LKTUdqXtaTgDMbcj052aIkjIOsWrdCVxprb29wkPxDBITh2vS+1tkMw6JZD+onHYSOrkZci21Aqm0SVWcxLTepE1qfkIn5yLXY/YLUQeiSHs8noHzDhJclssHo8j9ZVQw2gNhrLW51fX6oJTaB7gZSUdVEUNCaQSw1r4FfL3MbQteEU7BzE12XGjb2xDF0TN0WAOXgDcHTeFgqeW4lBeXItdSC5Kv8OcJnfxy2qT+Vk1Ba8RhwIOI7BOApchgl9ef0ePxlM1ZSA7F7CnqVvy9NeIY7T6NpbDW/lUpdQ9wLrBnJfuOehuup/6YONQmDk82cfieicMOE4cPmjjc2sThROA8xEE9l04k0rcUewCHIwNDRvEaD9yY0MkhHwnvKkasgzjTX4wEdG2WNqmBZADweDwOHUTXIT7yHyIvph8BpyNlOD0jCGtVycXDC/QG/JbNkLE0ekYP7W3qV80t9ojmluUBHzsB9yMBGPkS41okgv6XZTR/GPmd3XuQCidVS69RK9ImtRCxlno8niqig+gKE4dXIqnU2vy09MjEWxrLYgMKx4UUpKClUSn1f0qpb2b9/1UXVezxDJizPjd7K635dpbCCIC1jEOSqedLKN0FzNRB9HYZXRS7CfyTxOMZ5eggsjqIlnqFceTiLY2FUUqtqJQ6FfgCEoBcEcUsjVvQN2P+tUieqdyi2J5RgvMXTACHuFU3AP8sUq2kH0s+brqqq1MxZlzfXZQqGjlsdRCVmy/zBiRVT+4UdxOQLldOj8fjaSQuBddFwJeR59edwLFpk3qroYINA3rM6FUKAZRShaqBNSNZSRSwGMn/WxHFlMYFSO1ljyfDb4BD6Z3+/RISof7t3A0TOrkhsCWSHP0JVylh3OTp4zZrHtNfxzQ9oJtYAKxAX4ugQXJmlksa+KOTcyxipbTAoWmTaq2gHY/H42kICZ3UiA/3hvTmbf08sG1CJ9f3z7LijPboaSRVYT5jjgEWAo8j+a8rrglfTGl8BjhMKfUOkv4GYAul1FdLNWqt/X2lgniGNgmd3JL+/oITga8mdPLytEk947ZrAW5Eaid3Iy4QUUInE8CSJQubzX23TG/abb+FjJvQe013dirGjbfHILkxxyIPyna3lM7U6nBWz6MTOnkFknJnKXCzK23m8Xg8w4FZSFWZbDeeJmQG5UDg6gbINGwYzdPPANbarWvVdjGl8VTgDuCn9Gqs+7qlEMpt65XGkcde5K9UMgZREJ9x/5/s/s9Oe7QJcHXapPZL6OQ/Ljl19T0XfdTUss/hCxg3wfDWy2Nt6rIZfz75pntuMnH4MHAM4h7xBHCZDqK4UmHTJvUUMJITgXs8npHLJ8mf0H8SksfVU4TRHgjjyggusNaWk3GkIgoqjdbap5RS6wPbIhU5rkUiT4d89KmnJixFpnpzr5kuYEnW/9+if57MMcBnEzo5ATiqp1s9dM1PVp1xzU9WaWlqorunR80Fvn7yTeCCXU6r0TF4PB7PcGAu8mzNDQxcCjxXf3GGF0OgOnKjuRnJSVo/pRHAWrsEuAdAKXUt8Iy19rpqC+EZFqSAC/Kst+67DPnS3YBYocekTSp2/o57glq/p4f/AA9UEkwzWjFxOA1YBXhdB1F7o+XxeEYDJg5DJBXYO8D9dYq6vheYhxQ0yMzw9CBKoy9tW4LRPj0NfID4L1adSvI0rgP4BMOjFKfsHQT8AXl4gfjYHJw2qfezNv0bcDD9r62XMgmq0ybVg7g+eMrAxOFYpI76V5Ak58rE4Tk6iH7eWMk8tcJlKtgamaaciwsma6xUowsTh03AdcD+yDPPAvNNHO6mg+jNWvadNimT0Mld6I2ebkaemd/1QTCl8bWn+SewSy0aVnYAdlylVAuwEVL8ehEw11rbVWXZRhRKKQvFSyAOB1xVlc8gD9B7ch9gCZ1cFfElnIJYHTuQaZY90ib1eJ3FHRGYOLwCiQbPnvZvBY7UQXRjY6Ty1IqETk4C/gFsjtxnCpmSnJ02qSXF9vVUDxOHRwO/QAL+MvQAT+ogqriSxmik3uNepr+Nbz2r5LZzvyjVI4f7mJwPpdTqwGNImeRT3axxddquRGlUSk1BClwfRl9fi3Yk9cqp1lpvjczDSFEayyGhk1OBbwA7Ai8Cv02bVDmJuT05mDgcj5Q7y5f0/DkdRN4pfhiQ0MmVgSOQIIYngGtd5Z982/4WKYU5Nmt1B3B92qSOqrGoox6XH/FrO+/98Zmbbb90+h4HLGTi5D4zfe3AejqI3m2MhMOHRimNG90yp+S2L+4v21RLNqeonYMEja6IZJ25DTjbWpv3Xi/S1lbA9xFr4crILO+LwNXlZKdRSt2O5NmeiRgYXgJi+qfhsdbaYsHN/dsuV2l0CuPDSCTsEuBp5KSsgkS6TkFqGe5grS2UWHLUMpqURk/1MHEYAK+TX2mcr4No5TqL5KmQhE5ujFReGItYi9uQB/m2aZN6I8/2S+lr3cqwLG1ShXyGPVUgoZMh8G/kfpswdnwP4ycaLr3jZWasvnwyrQ3YXAfRK42Sc7jQKKVxwz+fXXLbl74k1shqyKaUWg+5x2cgwcIvIkHEsxCFbUdr7YIy2zoWuBjJp/h3xJd2BeBTwNvW2gPLaKNcf0ZrrS1WWKMflfg0noYojL8Bzsi2KCqlpgI/RlKlnIaPfvV4qsUHSOb+XKXRMoASUJ6GcAUwld6k9RMQBfJCpHpRLmPzrAMYk9BJ5X0ba8rliNuVBuhY1kRXp+a3c1blzKvmZbZZALzaIPk8ZdCAG+QyRGE8zlp7aWalUuqXSJ7h85DMIkVRSs0GLkGKVByQO63sXAPLYXKZ21VMJd6i+wOPWmuPyZ2CttYustZ+F3lD+1I1BfR4RjMuUvN4xLqRoQexVJ3eEKE8ZZPQyWZgB/rXPW8C9iyw2z/pH/loEB9irzDWiIRONiHTgX3GRdOjeOLeKSBBaK3AV3UQ+d9hCGONKrlUC2dlnA28Afw65+uzkGvmMKVUvtmDXH4OLAMOzueHWCx2RCm1ppsRxlrbWu5S3lH2UomlcS3gzyW2eYAKqnd4PKMNVzHnCMRnzSKVHa5Nm1R3oX10EN1o4vB94AxgXcTCeK4OopdqL7FnkBikMlK+xPgdBfY5FnFiH49YJdsQP7pjayGgZzmWAr+VkmC+nwFX1jpy2jN46uwFNst93m2t7fOyZ61dopR6GFEqt8OlMMyHUupTiM/zbcBHSqlZiE+iRYpn3Jfbfg6vA3OAcwd4HGVRidLYiphfi7EyfS0iHo/H4dKo/B2xPGXeOjcF9kno5H7FrEg6iO4D7qu9lJ5q4lKnpIAD6Dvt3I4UTMi3z6sJndwA+DqwFeI//ru0SX1UY3HLwsThSsAXkIolf3cJ+Yc97rf6E/JbZSuO7R3t+kodRD9qkGieCqkkKUzGD7JMzrbWzslZt6H7jArs8zKiNIYUURqBbdznB8D99E+Z85xSan9rbSFfWkX/GY2qU4nS+ASQVEpdYK19OfdLZ6L9MjJF7fF4+jML2J6+QQ4TgT2Qt1B/74xMjkEGjE8iVgONWBLPKLSDi6z+ZV2kqwAThwcgZWINMkBdZOLwVB1EFzdWsqpxLPI7rU/vAPws3k9/WFFnS+NU97mowPeZ9dNKtJMxyh2BBL98HngI+ARwJpJ27e9KqU2ttZ0DF3dwVKI0/hy4G3hCKXUpYvV4Dwnr3g34LlIX83+qLKNnlJHQydWQh/Rs5Br7edqk/tZYqarCLuSPih3rvvNKY51I6OSWSBBKF3Bz2qRqNtWfNqlFCZ38NBJNGQLPp03q6Vr1VyuchfH39C8T+lMTh2kdRC80QKyqkjaphQmd3ApJF7Yh8DzwuPclHWYMzyQlGV/aJuBAa21mPFislPoqkht7ayRupGFVgcpWGq219yilvoOEgp9OXyd8hTx8j7XW/rO6InpGEy45+DPI21sLsAEwM6GTP0yb1EUNFW7wfIA4OeemTWl333nqQEInf4ZY/8Yilr/TEjp5atqkLqlVn07peMwtw5V9yV+arAU4ELGGDHvcb/WQWzzDkEqmp6uQcidjSZxa4PvM+lI5rDPfx1kKIyB5cZRSf0GUxm0prDTW/OWmEksj1trLoaXcowAAIABJREFUlVJ3Ism9t0ROxiLE5+YGa+28Yvt7PGXwAyTnZ3ZqgYnAjxM6eUXapIazz+yN5K/f3QP8qZwGXCDNScDRiMXnVuCstEl5pbMMEjo5E1EYsxX3ZuCChE7e4pPQF6WF/D5TmvyBPh5PQ6hmdHQZZGYpwgLfb+A+C/k85rZTSLnMJAjPtfRn8z2l1NdL9JONtdauV8H2lSmNroc3kZxDHk8t+Az5B6AeYGOkROGwJG1SHyV0ck8ghSjGIA+IL1ZQHi4FJOhVeo4APp/QyU+mTWppVQUemexP/kTpBtgb+G19xRlW/A3JLZlLO3BLnWXxeApTX2eCTIDibKWUzo5wVkpNRlwd2oBHS7TzKBJwvLZSamKedDifcp+vF2ljGqV9J7Op+EyN+qreniHHWwXWjwHer6cgtSBtUo8AawA7Iw+TNdMm9WQ5+yZ0chP6Kowg1p8VgEOqLOpIpYf8U6zWfecpgIuSPg1xsehGzmMbkobG15WvASYOlYnDHU0cnm/i8IcmDtdttEzDAWtVyaV6fdlXkXiPtZFZjGzORmbKrs9WApVSGymlNspppw1JwTYO+LFSSmVtvymSpq2b4rNSFwHrVLBUfD1VbGn0eGrMz4Fd6asYdQAPjpSpw7RJGcRvs1Jmkl/hmYgooZcPRq5Rwo1ITdfcZ59Gyn95iqCD6CITh3cDByEvLLd4hbE2mDhUwO+QFEATkLiB000cHq2D6PqGCjfUqX/Y0neQ/LmXKKX2AOYCn0YyZkT0z5Qw133maq8/QoIiTwC2dzkeP0HvDMkJTkktxMe1dhP0lkbPkCJtUvchkfiLkRrn7cC9SDqn0c488j8O2yntL+MB0ib1AvJgbkcsZpnE2Ud6v9Dy0EH0gg6iH+kgOtUrjDVlNqIwTkSUizGIP9vlJg4rmYIchagylurhFLmtkdyrn0b8ztdDAoe3K7futLV2MWIA+Akyg3Qs4jbzELCntbbhqa28pdEz5Eib1DUJnbwBcSz+MG1Sw35aukr8C8nftR59A4W6gasaItEwJG1Sv3AJt/dBzt1t/hrzDEEOpH+mBRCL42zg5vqKM4woVjelRlhr30IS8pezbUGt1Vq7FLFMFszj2ki80ugZkqRNqhPJkVYRJg4z9WOnA//SQTS/2rI1irRJ2YROzgKuQ3KjArwKHJ42qXcbJtgwJG1Sb9K/TqzHM5ToQmYW8ikYBWsQexiueRqHBV5p9IwYTBxuAqTpTaA9xsTh2TqIzm+gWFUlbVIxsGdCJ6cAY9Mm9WGjZfI0joRObohUE3oXuDdtUj6YZ+RwHRLglmttbEICLzwFqCRP4whiFvBGrTtRtsyzq5Rqsdb6t5sBkqlvWYVEop48mDjUiM/favR9M28F9tZBdH8j5PJ4akFCJ5sQpWJ/JOrbInncdk2b1BsNFM1TRUwc/hjxj8tE92vgSzqI7mqoYGVS73Ev09+aV+VLh9uXN488BfBjcqVUEgjzjlLqAqXU+jWTxuMZONshyeZzHwATgG/XXxyPp6YcAeyHBEZMAiYjL0xlJYn3DA90EP0Qyc93MnAcsPpwURgbilWlF8+AqGR6WiPVOr6vlLoXSYJ7m7XWT4d4hgKTye/+rKgs2anHUxYJnVTAt4BTgZWRxPMnpU2qHhHF36F/HfMmYJOETq6RNqlC+U49BUjopAb2RCKW24Br0ybV8GICOoheBX6Vuz6hk9ORMXl/JNvEJcAffJ1sUKP+DNSOSiyNqwKHAg8CeyCRW28rpc5TSq1dfdE8nop4hPyVZFrxUYae2jAHySu6JmLx2wm4L6GTm9eh70KlxHqKfOcpgHsBuAl5VnwDmZ34V0InT2yoYAVI6OQk4EngRGBDYBvEkNPwlCxDAqNKL54BUbbSaK3ttNb+0Vq7G7ARknm8GakQ8IpS6g6l1L5KKZ/70VN3dBAtAY5HLAQZ63cr8F/ghkbJ5RmZJHRyApIkPNfaNw44qw4i3ITkl8zlY+DlShpK6OTEhE5umdDJGVWRbHgyG9gLmeoHsdpOAM5L6GQwkAYTOrlSQifPS+jkMwmdvCuhk7OrJCtIdZAAGJu1biJwVEInV69iP8MTW8biGRADUvCstZG19iTEhyZjfdwLqT/6plJqjlJq1UraVEqtrpS6Rin1rlKqQyn1hlLqIqXU9ArauF8pZYss+WrOopT6pFLqZqXUB0qpdqXUS0qps5VS/o19GKGD6EokMerVwK2ItWBnHUQdDRWsBAmdXC+hkz9J6OTvEzp5cEIn81lMPUOLNclfdlADW9ah//9BatBm6o13IC9Jh5Y7PZnQSZXQyR8BHwL3A/MSOplyCvFoY396FcZsupEp64pI6OSKwLNIEMvmro1bEjp5wmCEzGI2+XM4dgLbVqmP4YtXGmvGoFLuWGs7lVJ/B1YCNkCmsFcFzgROU0r9BjjFWlt00FZKrYdML85ASnm9iFz4xwN7KaV2LDejuuPsAuu78/T9aaTiSAviRP4WsLs7hj2UUnuUkt8zdNBB9H/A0Y2Wo1wSOrk3MiXWjFyDXwROSujkzmmTamuocJ5ivEPfBOsZLPL8qilpk1qc0MmtgK8gz6s3gKsq9GU8GDgFmc7OvCB/HrgMsWQNCxI6uSZS1nAycAfw7wH49S1FXgKactZbRBmvlOORih65lsDzEjp5VdqklubfrWzeQMazfOUwfc5WrxTWjAErjUqp7ZDB+cvIlEzGEfcaYCvE1+K7yE1TKnr1MkRhPM5ae2lWH78Evgechzicl4W1dk6Zx9CE1PacAOxrrb3drdfIQP4l1/+IyfM3GFwt1JlILcwndBD5smuDIKGTLUjalGyL9iTE/eNo4MJGyOUpTdqkliR08mqkAkS2xWcZcG6dZGhHrp/rBtjEqfSfXh8PHJjQyWPSJjUQZamuJHQyiRy/RnyaT0Asel+rUHG8FxmzcmlCFNFK+SwyLubShVgeHx5Am9lchkTQZ4/h3cjLzGODbHv4M8qio5VSZw5wV2utreh5VZHSqJSaDByGDGifQiJTn0Yu4D9aa5e5Tf+jlLoeuAuJRCuoNDor42zkzSm3QsNZwDeBw5RSJ1lrq/0Q2xXYGPhXRmEEsNYapdTJiNL4LaXUBbbchJYjFBOHqyEJZddC3sjHmDi8EDhDB9GoPjf/z955h8dRXX34vVcukm0w1cj0ZmEgoScxGAwGLphekqEkdAihl0AKJYAJJeBAICT0TgiQgY8SSmAIpgRCSUggBGwRegKig4vcpLnfH+cOWs3OrHZWK63KvM+zj+zZ3Zm7uzNzzz3ld7rBBiR7q0YgXqDcaHQY7TUh1+qMIPRn1no8jhOALxEplBFIuPjYIPSfqemoyme5lO0Wka/q00aj0d5iSK/fwkXXSMRbfzvZjL1DSe6+8lGFHv/3U/Y3DOj2YjsI/RlGe3shTo8GZC5/Gfh2Xj09KKunz0rYVvgtqITtyv27Z4xGpdR1iFdxBJI/cwtwubU2UV7CWtuulHocCZ2UYrL7+4i1tpNkirV2tlLqacSonAD8ucyx7g2shuR3vAY8lhJijsZWpHtlrX1TKdWM9D9eHWnXNpi5G/kuCs+Z4xCZkbtqMqL+TyvpecV9esLuLYz26pG0ka2R63mY0d7jyOQ4r9R7e5og9NuA01xe4DDn+esXOHHwtNzZL4CWXhxOpWxDQsoR4q3/HtmMxm1Jbte3otHeqArCyRe7fRZ6oRcBLwehn6lQKY0g9B8w2huLVE/PzmWWChh8RuPkhG0nAjsCtyI5yy1I8dRkxCnxAFLQnIksnsaDEcPpSuAGa+1nZbznceDsLl6zlvvbnPL864jR2ESZRiOyyizkI6XU0dbauPBtOcduco8io1EpdRa9UylZU8KWptUQz3L8fBmJGI650VgZryLhpHEUd7G5vCYj6nucjxgH9XR4lCYjKSPH12pQhQShH5JcydyXmUL6/f9G95n6OmkawZbsvZlnITmRScfInNMehP4TRnsnAhch+rFDkajcHln31cVx2pH7SE4Bg83TaK19ovD/SqkDAANMsNa+GHv5TUqp3wBPIsXLmchSPT3FWjvOWntRmQYj1tqnrbVpRSkRo93fL1Oej7aXI9B8L7ALsCIywYxHJp0lgDuUUlN68NgDmdEkr+hBkr1zKsCFkXZFVoCzkGT8KE/Nr+HQ+hKHUpwbVo9o6eVUzgYk6zlaxAPeH3iU5DmsFbg5475+Q/Hnng/cEYR+Re1zg9C/GsnV3xZYNwj9iUHo53ngvUHeEeZE4I4EgxEAa+3fkLqNE7PuOIunsVEptZ619uW0FyilvgZsZK3NesFWBWttPAdsJnCqUup94DLEgMxbMGXn3ySv6udTwUolp4Mg9Ge66s9tkQnmL0Hov1njYfUl0uRfRhjtqcGQv+WEp5cB5gehP7tKu30T8WjHvWtz3HN9niD05xntfQe5B1mkaMUCVwHTM+7ul8A6gId4Fochih5Hd3eMwAvd2UdOBQz4u0KXrEXX6RnvI+d7JrIYjTciyZapRiOwGxKOzmI0Rt680SnPR9u/yLDPONciRQUbKKUWs9ZGN95uHdtVaZ9VzgCiRur9Ed3YvChsafo+4gEbjtycW4EPqSAnIqczLjcuX8wk8xRSsBZP5H5qkBiMmyLFDqu5/z8KHBiE/ifd3PXdSOh0BB0yM+2IIdlvFoJB6D/sxKwjncWHg9DPLHnkrsEDjPZOQ1Jx3uxDBVc5WRnwd4YumQVM7OI1m9Oh81o23dJpTCBa6WUhujCbUp4f5/6m5R12ibV2vlJqNrAkkocXGY09fuyBgm5svjNsaXodkVFaCXgIuM51YsnJ6SmOBv6KLFaGI16gBcAxtRxUb+A80I/QWXTaAI8a7W3YHaM5CP35RnubIQbp5m7zM8BBtS4wykoQ+p8jgv7V2Nd7iFZvTj9G9YeM3J7lAeAgpdQvgakFjrJIBecsxKi8IeuOq200NgGfZ3xPFEbYTimlCyuo3YebiHi1nq10UEqptRCDcTZQuEJ/DDgNSQo/P/ae1ZHP8w79JFzT0+jG5peAw2o9jpz+iav03BMx/u4PQr/LxVgQ+q8a7a2NGI8bAy8Cvw1C/389Oti+wREUSzINBdZAmh90S48vCP23gclGeyPd//tVxb7R3hBkfmhA0jq6K5idM1DIPY2nAFshOYuHKaX+iUQGl0PymRdH7JpTs+64pNGolLo+tml3pdSqCS+tQ9pqbYFYuGVjrX1DKfUIUiF9NJJ7GDEV8QxeVajRqJQa7947o2DbasCX8SIdpdSydFjTt1trCws6nkAkeSYppXaNiXtf4F5z5WDXaMzJ6S5Ge/sgwv8gxQvnGO1dGIT+WSmvH4WkuywJ/DkI/dN6ZaB9i/F07igSESJ6qVURce5vxiKA0d4mSM5W9P0MMdo7PAj9W2s4rJw+Qv9NBqsO1tqPlFLfRJxh3wUmFTzdClwDnJqx0x4AqpQ9pFQnJ2+SUCmx558D9rPWZvLMJbQRfA34FiKt0QxsVvjhovxAaztKoJRSByFyQH9BLOjPEEN2RyQ38W+AsdZ2yk9MaCP4LiLxsQmi2l+VNoJJYx7MGO0NBzZF8qj+6nKKcgYgrg/vexRX67YCk4LQ/3vs9ZsiOZ6KjoXtjcDRfT2P0WhPI5qSayD5389WOmYn2XIOxcVA84H1qqX3199w944PkAVFIfOADfNcxL5Db8970fHWuODiLl/7xk+kAdBAn5OVUkOQBehopI5jRsx5lomuJHdWc4/VkRv4JQXbCh8rA4tbazfLajCCeBsRI+1GxFg8CbnpXoroDJVjDf8d0WdcDunkchISdv4XoiU4MW4wumM/B3wDMVa3Q9y5o5GCHpP3na4+Rns7Iq7ye4H7gQ9cflXOwGQnkqvv65FV8Fe4kON9SPhkMTr6Ih+AyGn1WYz2lkWUBv4PEXd+BHgqCv9WwPXITb5Q8qUVuHewGoyOHSjuEQ2ywMilmHLEhdXVY5BgrW2z1r7iJBBf6Y7BCF2Ep62170T/VkpNBaYXbqsm1tr3EAHxcl5btDKw1v4LOKjCY79KBaXnOdkx2lsB0SCMe0/+ZLS3QhUlRXL6DqUWp/FreVOSO5WMRDQb70t4rq9wNbLYLcxD3BhZgJ6UdWdB6H9ptBe9f1c6RN8Hu2LBaJLPqaHA0r08lpw+yGAPT/ckZRfClCHSnZNTDt8l+YavkG4JNdH4zOlRHgCuSNg+HxGYLSSpF3dEWtu7mmO0NwzxqMbHXw8cSAVGI0AQ+h8A33ePHGE6yXPXHOCPvTyWnD5IXj0NSqlxSNesbyKpHEneeWutXSPLflONRqXUyu6f/3N9pFdOe23CKN7NMoicQcXSJCf3D6U4RylnABCE/sdGe0cihqNCbl6LgCuC0I+rIjyTspu5wO+qOS7Xf9lDFjILENmWhyvMQdSke1QrNnbDliYNWN3YnPtOHEHov2u0dzEyIY5Azqm5SE79/bUcW04fYZBfLUqpTZGOSQ1IN7cPSe7qljmfs1TY6G3gLSTcUvj/rh65PE1OKQLkBh8npPze4jn9jCD0bwTWBn6GqCJMCEL/5ITXzQf2Q3L3FiC3/zlIH/s7qjUeV7ByLyL8vwvwHaQQ7peV7M+N+1mKp6s2d5xMhC1N64QtTY8jxnVr2NJ0VdjSNKr0uwYPrpp+dyTV5QHgSGCK68WcM9jJcxrPR5wzRwAjrLUrWWtXS3pk3XFq9bRS6kbkq/2ptfbDgv93ibW2rNzEwURePS24lmj3IZXxUYHAXOD2IPRzDcgcAIz2VkKMx6WRSuo3kdZYM6vRZtFob3vESIwbYvOArweh/0YF+xyPeEqHIx6wOUghyyZB6LeUu5+wpWk5pPHA4nR4AuYDz+nG5q2yjisnp1bUqnq66eyuq6ebzxi41dNKqbnAH621+1R736nhaWvtQaX+n5NTCUHoW6O93YF9kIrYRUhY8J6aDiynT+E6c5zv5FXuQJQNFgLDjPYeAfYOQr87ygY70LFoKcQifcAzG41B6M8w2lsD2B/pY/wCshjKqoP4A8TwLJzM6oFNwpam9Z3Ifk5OTk4aCxH5wKpT7Y4wOTld4kJIt7pHTk4pzkMMxkh6B/f/86iwuMTxObJgiecbttPRkz4zrqXdr7sxLoANESMxTjuit5YbjTk5pRj44eeueAa5j1SdrnQac3JycmrJ9ykWBW+g+9XEt5CsHWmpfQXuC0g4Os4QRAcyJyenBCrs+jHAORXYTCm1f7V3XKp6Ot5CsFystfbQCt+bk5OTU0iaMHalgtkABKH/ptHeAUhDgTYkFNwG7NIH2updA5yMeEGjhf184Gnd2PxKzUaVk9NfqIGnUSm1IqKpOgXJxf4ASbuaaq39vMJ9TkIkpjRwrrX29DLfuhvS6e5GpdRhSPOTouYmiL328yxjKhWePijLjgoHgYjw5uTk5HSXp4HN6ZzfZ5F2od0iCP07jfYeBLZAcoD+EoT+oi7e1uPoxuaPw5ambyFh7q0Rg/F6xHuQ0w3ClqZhgNKNzXmnrwFMb4t7J7RCnoHoIx4PTFFKTcza51kptRhwE6IkkVU54ayCf2/hHklYoGpGY+ZS7JycnJwqcwxiIA5HPG8LESmeY6ux8yD0W4GHq7GvaqIbm19HinUy44qHVgQ+DEJ/TlUH1k8JW5pWROSVtnH/fxw4TDc290iHs5wa0/uexssRg/E4a+1l0Ual1MVIa+JzEfmbLFyKdD86370/C5Mzvr5sUiV3cqpLLrmTk1MZRnsrI/3jNwJeBH4dhH7eQCCGk7M6GdHCjETUrwdOCEK/W/1m+zPOu/gGMJaOrhjtwEfA6rqxOSl/NKcK1EpyZ+3Tupbcee3c6kjuOC/jfxAt6zWstWHBc4shYWoFjLHWlpX6opTaDQlt7484924gW3i6x8irp3Ny+ilGezsD04BxyI3pzCD0K81F/oqwpakOpzPYFzqROAOxSAg8p4j9gDPpnO95MKI9+aOajKhvsBvisSlso1YHLAZ8m1zFYeCRodAlMjTLZKq19qzYtsir90ihwQhgrZ2tlHoaUXyYQBkNLJRSY5C85nustb9TSh2UYXw9Tmr1tFJqZfeoi/2/y0fvDT8nZ3BitDcF0S8cj0yAKwKXGe0dVek+w5YmHbY0nYnI0XwG/C9safpuNcab0yucTnGB0AjgSKO9Uj29BzrjkO8hzkj3XM4AQ9muH1VkLfe3OeX5193fpjL3dw1im2UNZ/cKeRvBnJz+yXkUT4QjgLNdi7xKmGotP0I8MEOAsYsWqptfuX+DvMNT/6AxZftQullt3s95GSkmiDOHXPNyYNK7bQRHu79p+q7R9iW62pFS6hBgV+Aoa+2HlQ5IKRUqpdrLeGROWykVnr4Z+Wq/jP0/JycRo71JSO/erwHvA1OD0L+ltqMasKR5SBZHKu1mZdlZ2NI0FDhBqc7GxdBhtm54Q3iN0d6fgtD/oLKh5vQSf0OqreN8TDcEywcADyHdMdZECqpACqrep/aanDk9QQZLpa/UGSilVgUuAXxr7R+6ubsnSf4WlkA8ng3IgilJhqckeRvBnKpgtDcR6REcCTGvAVxhtLdEEPqXpb8zp0LeBNZL2D7HPbKypLUMVQm3zzErLKoDTgB+UsF+y8ZobwjQHoR+vjitjB8jk0UDHRJFrcDxg/k71Y3N7WFL0+ZIFeo+yHfzB+CnurF50BYIDWR6WXInWpCNTnk+2t6VgXY9kn9ccYpRhLV2q7TnXHHOr4DNgD2z7jvvCJNTLc6luHPHSCRcmhdcVZ9TKQ65tSLe3Ur6HXza3sbCpCfeerUeYKsK9lkWRnvfNtp7C/H+fGy0d6KrBM7JQBD6f0cmgvuA/wJPIGLld9V0YH0A3dj8hW5sPlI3Ni+pG5uX0I3Nh+vG5s9qPa6cHqJ3w9Mz3d+0nMUoKpSW8xixESLb87FSykYPpHIa4DS37Z7uDNZaOxs4HGlmkFXKp7LqaaXUSkhfw9GIlf0Pa+17lewrZ8Dw9ZTt9Yg6fsX5GTnFBKH/gNHefkg6wGrI93s2cGUl+9ONze0f/OXr05ZdfuHZ9SM67qjzWxU3/GJsiEhKVB2jvR2R1JcoP3NpRGx2GHBBTxyzN3BG70RgFeDvQejP6I3jBqH/ErB7bxwrp39htDcSsE6bdEDTy20Cp7u/2ymldILkzkRkQf9sF/spvA8WMg6YBPwT6ezyj+4O2FobKqWmAx4ZPZuZjEal1DhExLIob0Yp9RhwtLW2K2s6Z2DyJrBUwvY2pBo3p8oEoX83cLfRnqpG+HGVzf/188sO3crb9eBPv7ZM4yL11ox6rjtnLK/+beR8xDjtCc6h+EY5EjjFaO+XQegn9Yfu0xjtLYe08FoZ8WkMMdp7ANh3MOslDmaM9jYApgIbIwuwqUHoTy/9rqodexzirfqW+/8TwMFB6A9cR08vhqettW8opR5BZHWOBgrTsaYi97OrCjUalVLj3XtnFOznuKT9O8mdScADVdZprAeWzPqmso1GpdSaSJucpRGh1L8ALUjF3uaI0v5flFKbWWt7xCuR06c5A7iTzgbAXODiIPQTw5451aGa+Wr33bDs5vfdsOwNwE6I2tnnwA+C0O/26jaFNVK2NyCRjP4YQrwZ8Q4UytzsiHSGmFaTEfUiRntbA6cBqyJzxtlB6L9e8k2VH2soMlEfisxntwC/CkJ/Xk8crxKM9r4BPE5HrukKwP1Ge/sHof9/PXzsUchvsBQd6WhbAs8Y7a3eF9pm9gQ1yG05Cvmef62U2gZ4DTHSJyNh6dNir3/N/a1JGo4zWj0qiCBlyWk8HzEYjwfWstYebK09xVp7MKJTdCKwDCIFkjPICEL/IURI+L9It4VZwC+QlVZOPyEI/VlB6H8bya1pAlYKQv/+HjxkWth2Lv2w4tdobzSS/xnXRRxBH9VdqyZGe99FKpK3BlYH9gX+brQ3vgeOpZD8zXMRxYbxiFbl40Z7daXe28tciPz+hQbCCODXvZC7uxfiUSqc64cgC7JdevjYtaN3cxqx1r4BbALciBiLJyEL4kuBCVn7TncXpdT1KY+bXVj6ZeQc6Lp1Tows4eltgAcL+ypGuBj+pUqp7YFtsw4iZ2AQhP4fjPZ85Ca1oMKCjJw+QBD6s8go21MhpyBGRqGHuhU4oz+GphFJl7QpKSlfacDgDLVL6fw565Dw3DnAd6p8yAnAFrHjNQDrIJ7dviKns3HK9jGIJmpPXmdrIhJcceoRo35A0svV0wC4uo6yNG2zyPxYa29EjNEsHNTF8zOAadbaG7p4XRFZjMZhSCJmKf6BXMQ5gxQXKk0MDRntjUWKG3YBFiDK9+cEob+g90aY05cIQv8xo709kLDteKQd4llB6N9Y04FVzsdII4S1YtsXIb1kBzJjSRYR10gKU7XZlGKPLoiRNJG+YzS2IMZhnIUki45Xk38AsxOOP5+u5/P+y6AVmPqK1VK2h8Dn1tpKZNmAbEbjS8iqpRRrIm7PnJxOGO0thlR+LUvHeXcS8A1gSq3GlVN7gtB/BHik1uOoBkHoW6O9g4AAMWiGI6H2z5G+0AOZz0lPeWrpgeO9jyw+h8W2twJ9qcjjXOC3dDaoW4HLe6Ew6l5EjWA1Or6nBUie3WM9fOya0cvV030Oa+07PbXvLDmN5wF7KqV2SHpSKbUTsAcV6P7kDAoOQLqVFC5UGoAtjPbWr82QcnKqTxD6zwJrI171OxDR7XWC0P+opgPrYYLQnwvcSnGkoZWeyXW/BzGA4n6lNuC2HjhepdyMyGHNRoT35wHXIVqrPYorQtwUuBb4FPgIMWC3GtDpQ72c0ziYSPU0KqUOSNj8EHC/UurPSOeBD4HlkGqsrZFwwDI9MM6c/s8EkkNXIbA+eQ/YnAFEEPr/ZeB7FpM4GvGufgcJvyrgzCD0u9sWrYgg9Ocb7W0J+IgnzSIezX2C0O8zVfcuZedCo71LkcrpD52B3VvH/xySd9pSAAAgAElEQVT5XY7urWPWmlrkNPZFlFL7AIfRoas9C4n4XWetvb2ifVqb/O0qpUKK7fFykjettbYvVa71CZyye5/pc9nbGO2dAvyM4q4xc4AdgtD/S++PKidn8BC2NBngGESb7U7gWt3Y3CM5dUZ7SyFybG8GoT+/J44RO94qiBPkzcHcMrGv0dvzXnS8DY7suij4n1f8EBiYc7JSSiEe7u8idls78Ani1KtDbLvbrbXfy7rvUjmNZVUB5eSUyfXAT5GqvegiXYgUDTxdozH1C5wsxwRgXUTf65l8YszJQtjSdCoSDo28/RsDh4YtTRN0Y3PVNQ2dp6/XvH1B6BflcIUtTfVIDvWHurE514odROSeRn4AfA/xKv4EeMJa266UqkMiw78A9lFKPWWtzdRFLNXTmFNdBrunEcDlLl6HhKMt8CBwWBD6n9R0YH0YV0AUIAajQr63mcA2Qej3Ox3DnN4nbGlaBtFPHR57ai5wom5svqb3R9VzhC1NGpH4Od5takdy7S/Ujc35hNeL1MrTuOHhXXsa/3H1gPY0Po94Fde11hYtCpVSDcArwGfW2m9k2XdFvadzcirB9cXdxHUpaOuNsNUAYBqwAZ0n/K8hengH1WJAOf2OzZCCkbjROBLYFZG+GkicghiMhfqNP0Oqu6+uyYhyepXc08g6SOvCxCiCtXaeUuoexCOZiSzV0zk5VSEI/Tm5wVg2+1E82Q8H9umFbhI5A4PPSM5Hb0eKGQcMYUuTAn5Ecj/zeCu3nIFKXj1t6boGpaL5I5OnUSk1EumxuD1SBRafzEAKYdL6yebkVBWjvSHA1xGx2hkDMNcvSbwY8ihBTvk8gxiOI+nsKFgAXFGTEWXE9Zg+CqkErUN6TF8ahH68kGcIIu2VRGPPjRCM9oYhsnObA28Ct+SpN7VB5Wl3ryESiaeVCE/vDryadcdlexqVUksAzyHaY5sgHQ+WRCR3VnWPYVn2mZPTHYz2tkckNp4AXgBm9ESP2xrzMOIRKiQEHhuABnJOD6Abm0PAIIbMHKSn91zgaN3Y/Pdajq0cCnpMn4ekZqyNhJunx3tM68bmRcBbKbtKbDxhtDfUaG9Po73TjfY8Z/xlHePiwIuIHuIxSE7lG0Z7aS0Ec3qS3NN4PbAy8KRSahul1BAApVSdUmoyMB1Yxb0uE1m8FacjcfJDkT6I7cCvELX5bwG/QW5E22cdBIBSakVEAHUKsDTSTuweYKq19vMy3j8SsZx3AjYCVkIm15mI0Otl1tqiCroocTaF56y1EzJ+lByH0d7myDmyPlLufwHw62oYO05i4//oHIYah0wkKwehv6i7x+gjHIdUTo9APEWtiDjwUbUcVE73MNrbGalgXBN4Fzi9J7QMI3Rj8+thS1MTkh87Gni+UG7HaE8jhuUuSO7fzUHov95T48nIt0jvMb0DcH/s9ScAt1Pcz/zk+I6N9pYF/or0gR6JzGEXGu1tGoR+li42pyK/ZRR9i459q9He2vkCr3fJcxq5Crlm9kW6bYVKqc+ApRDHngL+kLVyGrIZjbsCT0YNrkUGSGLRwLNKqR2BfyF5Iz/LMgil1BpICGUM0vZoBvBNJJl5ilJqorX20y52swXwOyQMMx0xOJd04/4l4qrdxlqblEv3DskNwf+b5XPkdOBW2A/TcfMci3gKlkUWIN3lEIrPX+WOtx3wQBWOUXOC0H/baG8csD+yGPonMqF/UduR5VSKMxjvoOPaGAfcYLQ3LAj93/XUcV3l8D8SxlOHLMC2Rvo2LwJOMtr7fhD6t/bUeDKwGek9pjcnZjTqxuY/hi1NOyNOiHFIlejpurH52YR9XIp4ZKL9L4bIgv0GESgvl31ITtdaBVge+F+GfeV0k7yNoLXA95RS9yNz5YaIwfglcg+43lpbUdekLEbjSnRuAB9ScJFYaz9SSj2EXDyZjEbgcsRgPM5ae1m0USl1MXAiIpdwRBf7aEGKBvxCj6JS6mTgceTGczRwUcJ737bWnpVxzIOasKVpFUTv6TPgkQQdtLMoFvIeAfzQaO+8hFykrKxAcc9ZkHyn5bq57z6Fk9b5Ta3HkVM1fkFxocYIxBPfY0ZjCfYAtqFDw3Goe1xttHdfEPqzazCmQv5Heo/pxIW9bmyejjgSumIPig3SocBuRnsqg4cwLbKhSjyX01PknkYAnGFY1ZaaWfIPWxFDMeJLihOLP0Qm87JxXsbtEJHn38aePhMJF+zvws+pWGv/aa29NR6CttbOpsNQ3CrL2HKKCVuaVNjS9EvEG/xbpNfs/8KWpq/HXroe6RWbK1ZhKAGSnxVHA3l3mQGK0d5KRnu7GO19rdZj6QbjUraPdQUfvc2+JLf4bKNv3DPvJb3H9O97ezAuB3KKy39c1m2+BpkjC2kHXhroPcf7Isp2/RjIKKUeU0r9vCf2ncVofA/xNka8CkxSShXuY3PE45eFye7vI9baTk5lZ/A9jazCu5NbGK302lKeX0IpdYhS6lSl1NFKqTyPMZ2dEa9vPRIeWhzJQX3AiepGvEryeq8OeL8K4/g/JF+1sDJsLvD7IPSbq7D/nD6E0V6d0d71QDNSOfuc0d4zRntL1HholfBuyvZPapSLO49038yC3hxIEk6ea0ukInQeYpy9BWxbhR7Td1PsCVwE3JfkZXRpNx8g6QXXAu8Z7Z0EXAI8idyD5iM9fluQyFu3MdrTRnuruvaMOV2RF8JMQObaqpMlPP0EsJdSSrl4+R3Ar4EHlVJ/RFakE8gu4bCW+5s20b+OeCKbgD9n3HfEIe7vn1KejzqVfIVS6iVgf2vtv9J2qpQ6C/GGDiaOoNgroZD80Y2RKmaQfKJJFCejXxWEfpKHMBNB6C8y2psEHIl4SuYBV1IDz8NAw2hvBJJicgBy47kDOLPGeZTHAnsji5V6t21jpPpvz1oNqkJOR8ZdeG3MRVI6UnFeyC2Qz/9UFcPG1yNh2njIvB1J7ak5Qei/CqxrtLcqck5Wq8f0CUihzbJ0FMJ8hlRAd8LJez2ELJILORv4N3AhIh6+vNvHpxR/p5kx2tvF7XdxoM5o71Fg/yD0uywQHawMdE9iGbxOZydf1chiNN6E5JSsiHgdr0QSp3dHjDoQr2DWIofR7m9aS7Roe0UeBaXUMUhF9j9JLi+/GLgLMVrnA+ORXo3fAR5TSm1grc2TmDtISxMIKchhDEL/r0Z7eyCJ5uOBL5BK6nOrNRCXF3kRyXmqORXg5E3+jFTZRsbZEYAx2lu/hlXpx1I8AQ8DdjLaG1WNhUhvEYT+HUZ7w4HzkQKxTxCDMXXBbbT3LaTgI8rrG2K0d0QQ+rdUYTyPGe1diuSPt9ORhrRrEPp9qmdzEPpvV3l/HzmZrl2RauwZwL0pn3tLkotdGpDCu9nI79OC/K4LgKFGe68BOwWhn1lI3bVejVeCG0SCqJyczUGJCge91XgtMFUptbK1Ni2yURFlG43W2hcRr070/zakInljRGrgbeCFeIi5liil9kTCBi3At621RROetfak2Ka/AZ5S6k7g24hMw4k9PdZ+xG2ITmeSt/H5wg1B6D8CrG20VxeEflxrMCcFZ7hthFR1vhiE/ju9ePgtES28+oJt0WJxN+DOXhxLIYuVeK6B5PzWPksQ+jcDNztNwEWlvGZGe/VIlCS+cL7KaO9vQei/Fnt9lgKOaDynGu1djRgks4D7g9Cfm2Uf1cZobxnEmBsCPBCEfo8s3l3U4gWkWPJYYAujvUuC0H8z9tJRKbtQ7hE5QFZzf6NraD3kuqnEyPshxYbqMGBjo721gtCfWcE+Bz6D3mbkj8i1/LRS6gIkAthCwjeT1ajsdlcJa+3fge4IxEaexNEpz0fbM4XGlFK7Iyu0j4DJ1tr4DaArrkSMxklpL3AV12eVOZ6BchrfiIQt16NDnqMNOEQ3Nie2BswNxvJxifUPI+kY7cAwo73fA98PQr83FmQbk1yVvhiyWKiV0fgnJA0hfs96F/HU9UvK9OTtQHL++VDgYODHTmfxJCRKspTR3kzgeLdw64TR3oqI/uc3EcHrS4LQf9N58fpEH2qjvb2Qe02IGGSXGu39OAj9y0q+sbJjfQ2RfBuOnPsTgION9rYKQr9wbnuS9A5NpRgKbGK0t1IQ+u+ljGEZxMj8X8zgX5Pk3LSFyEIuNxoTGOySO4iQf9RK8NISr7NktAMrMhqVUkMRVf7RiNH3WpIXr0yik74p5fmo0rDs4gallIfktrUAW1trKxGp/dj9LVm1PdjQjc0LwpamLZEcqJ2QivnrdGNzXnxSHW5BPH2Fk9M+SLeJuLpAT/AWyfImc4E3euH4aZyGpJlEOnqL3OOw3hJONtobBUxDNDOHA48Bx/SCCPbiJBuNQ5BcYpAmCyfQEcYcD9xttLd9EPpfqQkY7a0NPIt8h8MQ79rBRntbB6H/An0At3C6ic7eboALjPYe6QHv2q+RBXCk9hBJDv2WggLMIPQ/d0Uvv0R+/zrK6/ELcq4uhaR2fYXR3grIXDUBMZDfN9o7IAj9p91LHkMWckn9518q8/MNPgaKi6ZybqaHvoWsvaeXRjTGvkvnC3q+Uur3wCnW2qyr/unu73ZKKV0Y3lZKLQZMRAookoRZk8b4PeSG8z8q8zBGRDeLSt8/YNGNzW2A7x45VcJob0lETSDuzRiBhM16w2i8HwlPjqDDw2ERQ/L2Xjh+IkHov2e0tw6SXzkJyT27rJe7ljwIfIOOe9+2SBX3uCD0u2o+0B0eI/lePQe4z2ivgc4GY8QIYCqiwRhxCWJ4xw2kKxHjpC+wO8WtM0HGuQ/ymTrhilR+imjxjkLyck8OQv8/ZRxvIsmG3zeN9nShhz8I/SuM9p5DemAvhcjOTaTruXQIsT6/zjs8HQlnR+9fHQiM9pqC0P8vYtD+AFkcRK+ZC1yR97VOZ8DE9SrEWntQT+27bKNRKbUcUuiyOuJdfB7x5DUiSfOHApNd95ayE36ttW8opR5BimmOBgrDD1MRT99V1tqv8muUUuPde2fExnggUuzyDmIwlswFU0qtR4KX1G2PCjZqIbab0wdw1aqHAgciXoBrkW4sPRVuH0FnLdRCSuX0VY0g9Bca7U1EVqqbus3/BA6stcizmyTPqcWxjfY2QoyqwsWydv8/DBHm7hGcwTwNyW8bgRg4c5H2dw8iv1OavMbasf9PItlA2tBob2gfab85lGTPqia5EAXkfN2NDsN5F2CS0d46ZbQDnEtySkaiFFEQ+i/i2nga7a2MRAFGubG1k/xbaCQd4OmCbZOQ+TM+Dzcg95opQeh/bLS3IaLSMQVp8Xix+7w5adhBbjX2IFk8jechBuMlwFnW2lnRE0qpxRED73jE2Dos4ziOQnJKfq2U2gbR4/oW4nVpRkJThUSJ31/d/FwT7uuRi3M6cHDU6rCAL6y1lxT8/4fALkqpp5CwwQIkrDMFufCvocpq6jn9A+cFeAiZkKOJaH0kJJ+lvVgW3kfC/avEti9CqiV7BVd4s6XR3uKAzlsWAmJ8JS0WGpCipR4lCP0zjPamI/fWkYgMko+ESo8g2ZiyiBRMIXMoDvuC3Pv6Su7x/SQrIsxH9Fk74WR49qDYoG9AHBFddSi7Ail2LOxgNQ+4tqvUhyD033U5kcchsnOfIqoiSZX+x9DZaFyZdCN4W6O9xYLQn+0KgA5PepHR3kgkKjYHeKGX8p77PHlOY8+RxWjcGXjKWvvD+BPOgDxRKbUJssLLhPM2boLoXU0BdkQEVC8Fplpry9GjWoWO1ekhKa95BzF6I+5B8oXWQy70euSifwi4xlrbaxN1Tp9jG2ThUnjzHwnsYLS3SRD6f6v2AYPQt0Z7ByOTZhQ2bEU8+0UhuZ4mCP1ZXb9q0PAayR6keYinqccJQn86Hek8GO3tBnyfZCMQZGxnxLZdDvyIzgbSfODGvmJwOEPsdCRPM/I6zgeuTrnu1kWM3vj3UE+Ht7wUU4E1EE/lAsSQewQpKipnvC3AqQBGe9uSXCWtKO6g9jzpc/BCJIL3VNpxjfb2R9IKFiHf0edGezsGoR9fKAw6Bmt4Wil1JFJrcmGU6qeUOh5x6MV5wlp7cNZjZDEaF6Pr9mxPUeGq21r7HlIJWM5ri1yI1tobkWq7LMe8BzEcc3LibEWyxMYQ91zVjUYQw8Bpsx2FFIdNB67LvX09j5M6mgR8D5nkbwWeCELfBqH/otHei0hOY+QdChFj5rqk/fUCSUL7Ec3AEUHo/zW2/RykuHAPOgqeHkOiLn2GIPQvMtp7GMlhHAbcGYT+8ykvf4Pk8PJC4F8ARnt7Ix7H5RFj7ZQg9P/hjrUQ2MeFmscDrweh/1aFQ38hZSytxOaaIPRnGO19QHrr3dT2g0Z76yEGY+GidhTwqNHeioNesWIQhqeVUhsBvwHOj0kfLgGsmvCWVZRSl1pr/5nlOFmMxhmIYGkpxpJLAOQMDD5EPDUNse0L3XM9hkve71OT+CDhV0j4N5qI90VSXo5z/98BCQfHq6drVZCQ1m1kFlJVXuSlcjmL33UG0jqIgVTLqvhUgtB/hTKaRTjj669IJXiht3EhcJnR3k+QKFZkzG0HbG60t1kQ+i8X7Odd0ls8ljvmL432TkHSuRqQxcc8t9+kxcX+iJxUoaHZBrzSRZX44RQbpwo5JyYDj1b0AQYIg9TTuC9yzl+S8JxFvPaRw21JJCVvPyRnvWyyGI2XApcrpS6x1r4cf1IptQGwFwUC4Dm1x2ivDqm+OxK5of4BuDAI/bQOPDnC70nuXtNGQl7VQMRpx12E6JWCaDSe1MOVwjXBeW4Op/MiYSRwqNHedUHov+S6zhwBHFGJgHYPcBtSnJPkbUzzygHVMZD6GLshXpZ96FAfGImkesSLgRTyO5+NVGpXlSD0LzXaewnJYRyD9Le+JqlrkYssHIMUt4Ru7C8hnuBSjCF9/s77U9f6yqwNWwB/TVOwiXkfP1FKPUoFgvOpRqNSKi5q/RYQAM8rpW5GhE4/BJZDukjsj+QCvp11EDk9yq1InmnklTgJ2NNob8Mg9BPFuHOkUtdobyfEyI4qVr8Adq91p4zewFWOP4OENaJJ+LvABKO9rwWh31arsfUQO5J8PxwG7Gi0twZSST8E0dK8jdoXjtyA3HcLhfYXAQcFob+glgNzEjgrAJ/1RtW9M8gOMtpbiKQXRPe7uMEYoRGx+p4az+OU2bc7CP1rjPZ+B3wd+LRMz+99yDkbXzAMQ+bmQU0tPI1KqRXpqMtYGqnLuIcy6zKUUiORRcxOSJrfSshCYiZyv7nMWluqGcA45N5UtGuSFRPepryc306U8jQ+TrK9rpAQzqGxbSCrvV1Jl3/I6UWM9tZFfo9C78lwpJPAXuSyDSUJQv9Jo73lkYT0duDlPuBd6i12QRL3CzUjhyI5YTsB99ZiUD1IK+JFjmtktiHX0NfpmKAnAnsZ7e1Wy/MhCP0FRntbIhPNjogE2vVlahP2GEZ7ByGes2FAndHebcBRWRaprjf3Scg8U4d4/s8vZYAa7S2NdKtKq0iOU2neYtUJQn8eXXiHY/wB0W79GmIgW+QcnlaGxNDAp713L0ul1BrIInsMcm+cgUgsHQ9McVKEXUVotkAk/j5DctnvQcLIuyJpMXsqpbax1qZdR4sh/c/j3EBBAV0BX1CBlFspo/FsBquTdwDghKL3Ivk3HIUUc5Q0Go32xiKSFVG7sct6uQ9yzXEVpb1SHdsbGO1tAuyJeKTuCEL/1ZSXfo3kQqCRiAE10IxGH2lckMT6FIetJyPXUNLNuNdwHt87qV17x04Y7U1BROgL8y33QQy/A8vch0KiVhPo+N5PBHYy2tu4hJd7VTqqn7vCItXZ/RKnp7olYiTvhSgsXBmEflDbkfUNauBpvBwxGI+z1n6lNa2Uuhg5d89FUltK0YLkGPqFHkWl1MmIE28zZD5OkqMCMRiLUhOcXnXSvL0UolGaiVSj0fVVzulnOH3BaUj1bTvJyfIL6GKVbbS3FtKFpwG5CW8J/CChH2tOP8Fo75d05LaGwI+M9k4LQv9XCS9vRrTf4ivRufTRYjfnnWqrpHI0CP0PjPb2Q8I7bUj0pA7RQ/xuwltGAoYaG419kNMovuc0IJ7Z48rMpZ6ILFQLDfV6RE1gX5JDcCD3tKTK5STuT+rL3dcw2tsCkQQaj2hunlFQEb8AWcyvgFyrMxJ3Mhjpxepp52XcDgn3xrt2nYnkSu+vlDqpsElJHFfFXFSUYq2drZS6CEk124p0o/Ft5Lopl29SQTphkup+Tv/maGRFU0+6HEcbUhVail8hGpbRqn0Y4nm6ogpjxGhvuNHetkZ727jJPqcHCFua6sKWpuX3X3XXiYjBOAK57ocgk/J5RnsrJbz1bsR7UWiAtSEhjT7lZTTa29Bo73kkPDfXaO8mJ0yelaeRiuIo/WYs8ATilY2zANF0zelMXJg+og1Ytsx9fIPiNAGQe9r1RnsHJL0pCP3PkFBca+wpiyx2Fri/zyLGZ5/GaG97pLJ6MnIuboNI6kx23tjrkSrpSNNyptGeV6vx9iWU7fpRRSa7v4/Eik2w1s5G7isjKOhjXgHRPahULvkTwEZKqS6Po5TaFCmiy7zorchoVEptrpQ6Vin1M6XUcUqpzSvZT06PcDLpUhytiJt6B9dloBRbkXx+bOKKJCrG3Qw/Au5CKpE/NNoz3dlnTjFhS9N+SMjjP5N2/uJxlI3LB4F4HHeOb3SFFBOQMGG7ezwETHC6dn0Co70VkJvlJnS0mdsbeCDDPjY02nsFuTaakTyk5524+d0kp3iE1KBblNHesi5tpK/yN9K/r3KrtaPuXEkMAa402ls95fljgfMRg74dyRPcAvEW/wTJx92snxSzXUrne3kkqXMxUmzhIY6B6LxvAG402uuVlqN9GlvGw6GUshkeZyUcbS33tzllNK+7v03d+ERRw5I/lXjNFcgnuy1qtZyEUmotJEe4HdH6zEQWyR2UUhsjoYHoS1JukCilZgIHWGt7RPQ4p2yWTtnejnQ4+XeZyfutFGsUguhAVVw1arQ3BjEW417Qe4z2Vh6Ici5xXNuxgxHR1XuBB6otxhu2NG0HXIWbdIYOt2gNYfFRLMmeNNzCYhcn20QfFQw+CvGCF1YHDkd6Ka8fhP5Lpd7siiceR8Lw0T4mAE8Z7a0ehP4so70dkKT0KPRpgX2D0H+/eh+jNK5V3u9xzROM9t4A9nd9kHsVlwKzCvCl8+5F24cg3ot4paYFfpZhsfFHxCM4KmFfIGkD3yWhD7k7R89Jeq4/4b7jNCPja4inNCmS1AZsiyx20vY9ETgFqbZ9Bji31sVT1Ub1biHMaPc3LfUi2r5EJTtXSh2DLBL+SYkIobX2daXUz5GQ+D+UUj7iSYwcRMsj3urvIPfIs6y1ryfurARlexqVUmsCf0ZyK55G3OFHur9Pu+2BUmpc1kHkVJVnSF7pvxmE/isZqj2vRERpC5kP3NLNdmN7kX7eeUZ7WxrtnWq0d8hAXDEb7R2CeD+OQ1aPtwL3R4ZZFfa/rtHePd9eZ937jzTjRjz1gNzPttr9C4YMTfzpNSXCzc6j82PgDKO9Hu+xXAFfJ7nwoR2ZFLtif2TxXGic1CE3+B0AgtB/GgkP7oRUMo4JQv+hbow5E86z/xSSgzTcPdYBpjstzV7DtS78AHgFeN9o7z6jvWgy3Bmp9owznwyC+M7LvTnpnsmhJBdpDRjcPTZNpuVj5PxOu5enLu6M9vZAWiTuiBil+wMvGu2lSRP1S5S1XT76A0qpPRGx7hbg29baxAV+hLV2KpIDW4cU1VyLRIgeQsTlv+eeO8tae3YlY8riafwZshrf21rrx547Syn1HeB2JL+irCq5nB7hZMSIb0BOjqjV2VEZ93M24lHemY52Y38BTujm+JYgOVl9GNIFZSwy9nnARUZ729TCm9JdjPaiz3M4MsnfhYSVfkNnD+4oZILcE6ng7c4x10bytUbM+WKInvPFEKYdtxKffDCUPQ77hIN/+gHXnz+WtoVqvrWqHTk/Dg5C/+OU/R0KXOZeVwecbLR3dRD6J3ZnnFXmWcSzEveKD8W1kOuCNUhO5xhCQX6eq9jtqo1qTzEF8WbEFxZDkEk/qZCp6hjtbYx4Owu/r+0Rr9ZkRBMx6btsIF0vMZEg9N8w2tsGMU7jPaVbEZ3Cgc6FSO/wwu90LhJ+/zcd4elCNCndYFwe5G9i+6tz+zifHhA6rxkZbMKktsQZiTyJo1Oej7ZnagWrlNodsak+AiZba98s533W2qlOS/sQpOI66nnegtgGN5a7rySyGI3bAncnGIzRQO9USt3rXpdTI4LQf9l5hH6KeCZeA36R1fByoSTPeZrWBZq7aGtV9q7d2OI3uxARM40miMiTcKfR3hrV0MMr6C3sISHZW3rQIL0LCQVExswPCo4bN3BGIXl43TIagbPoKHQBYMG8Om66sJGdD/iUPQ//hIk7fjnnsEnjT104X80D7i1hMI5BJpjCCXsEcLjR3h8SehrXiqsR43wYHUbVPODRMs/XZ4CDKPZchWTTzetJVib5Xj0CWK0Xx/FDig24YcC3jPbWRKp3WymuuJ9NBZW9znCchug11iPe4FbkOik6/8KWpiWQRel7urG5L6ZSfIVbVK4OfILcE9YC3gtC/4OCl01DihFPoMMMmoZclyDpJ0ci13tU8b9XEPrxQqCIZUnuFqOBKX2ky1F16F1PYnSfSUsniCIeaTmPRSilPGSB1gJsnTWMbK19C3H0VZ0sRuMydH3hzyAhqT6ndwlC/3U6i693Z19vAhWvShJ4HskP250OwzGqbEy6oY1BLsZUA8BorwHQpZLbncF4JR3dIixiAJ2LhGvqgL9Xo9OJ0d4GwNZ0Ng6Hkb4StYhkRnfZlITQvw3ho/8OZYXVF7Yut+Ki0x5oveuyhPfG2ZHkSr16JMWgTxiNrnPPNxEZCoMYjFdRvgbfq+499XTcD+chxuQL1b9X9ZIAACAASURBVB2tELY0DUeMhI91Y/MHXb3ejSMpJWQOvfs7rEFyaslCpGHA/YhXpJ6O6uc2ZOxrGe01BaFf9sQJEIT+GUZ7f0I8qkMRCaRHC42bsKVpceBG5JxtB+aELU1H6sbmPtnu03nwL0K+ywb3dw4wzGjvQSRXtdWFqE8z2jsH6bzWEhNIP8lo71rEEz0H+L8ucsJLdeYZhnx/ZReQ9WV6WacxqkDeTimlCyuolVKLIRJSrUhUpEuUUt8DbkJyEcv2MPYWWYzGj5E8mlKMR1ZOOTmJBKFvnWTGbkgag0UukDNJ75maGD5wUjHX4SQPjPaeRcKtSUndmyIGY2SoRpWI5wKnIhPbAqO9vYPQf6yCj1bIJiQHSBpIrgqdh+SedJe3EW9tJ9rbFIsv1f4y8HPd2JwqAh3zNKR5amyJ52qCW9h01au3CKO9MxCv91Bk4rZIN4aLgYuSvC7unNsPOVcfBv6cxTsTtjQdjnR3ABgatjQ9AeyjG5tLha5eQMJKW9CxEFmAVBnfVe6xq8BjSHekeA7pcKRb0iKjvc2QlIbd6cgVHYXoN/7EaO/HQej/hgwEof8MYsR3wmhvPPC9qx4bvv/KTQuW1/orQ3UEcEvY0vTf7Zdf/wVkAbc/8hv/Hng45bfdFrgAMejfRYp3qvr9OpWIX1Mcxo8konZEPIlRtWzULebtpP0Fof8aEk3qkiD05xntPY4YmXEUcj8eEEZjb3oarbVvKKUeQbQaj0bO/4ipyJxzVaFGY1TdbK3t5IhTSh2IFLu8gxiMfa6ZRhaj8THgu0qpfay1t8efVEp9GzEEbq3W4HLKw2hvApITtxC4LQj9f/fw8YYhRt4RyAUxHTi+XC+CW0HfTUGFn9HeKsB5FN9MPybBy+iKA6ICheg83gx4xlW9xj13uyfsOyIyJBcD7nPv/6icz5LC2yR7huYhHpF9Ec+mQsZ+XhD61ciXOwf5Tgs/57xFC/Vto8e/lup5dtpuFwKrGu21IGFun+R2oAuQibdf4yrYf0pxqsBIJG2hyLg32tsF8XRpxDNzBPC40d7u5VSWhy1N2yD5h4W/z2SkJdx2ae9zC61dkPDwYe7YtyHnTW/KH10KfB85L6Jrbi7SKeozN9aPgL2N9jZEckCjz1qHGOfTjPbuCUL/v90ZiNHeEcDFY1ZcOGTsKguH6mL/Zz2S3/0+8p1F/eP3RPLEDovtzyAFYdH5sDZws9FeQxD6v+vOWGP8hPT7UDTufY32srZdXBW5x22DVFfPRoSmr4kVLl7hXpMkm9bd3L4+Qy9XT4PUDDwD/FoptQ1iyH8Lub6bkUVTIZGh/9V3rpSajBiMGplTD1aq6Cf5wlp7SdVHn4EsRuPZOKNQKXU08qE+QJIst0KS+WfTz6UO+htGe5chq9Koy8cPjfZODUK/J0+sO5AE+OgGux3wvNHe2rGcnCxcgVSmfhOZuFsRj5aX4snZBclfKjyHo3DPXhRLE8xz++vqnNeInEd3vr/HkDBdQ+x4bcjK84fIan8xxFOVSbrFaO9biIG9AbIinQb4Qeg/Ek2myHdYhxiRqUVQRnu7I4ZsNJE1uvfXIS3KbkY8cJEn7oL+WJiUwJ4kT5wWuc918oYZ7dUjfWHjRUyTkfOtHM3GH1NsMAwDtghbmlbQjc2p2qnOOPwFKa0OXfrFN5Hq5WeD0M+UdF8OQeh/aLS3L7KgKEzuT3IURLIecULk2q24SYDLt/0VUL/M2EUsWqQY3lB0i9DzW9W6SMV74Xc+EjHKrgpCvzD94AKKFxAjgAuN9m6tYq5fkpB+HIXcG8oyGo32zgZ+hHzfhVbGRUiE5SCAsKWp4ZYXhtoDJ6zdFrar+LnfDnzTaO99pMvMGUHo95Wc3uz0ss3ovI2bIHbSFMRj/AGy0JpqrU2rhC9kFTrSPw5Jec07dG9u6jZlG43W2v8opbZFJpGJ7mHpOElnAgdWovuTUxnOw3gIHTfFqNPH+UZ7fhkC3pUcc006G4zRcesR46Si5FvXS3VbZBKeiCQA/6FE27HVKU7KB5nI10jY/nvkxtrVOd+A5O9WTBD6odHeJMTIiK6TN4EDgtCPpEfuSXu/8xocjaR7PIV4Cz53z30LMUqj33wp5LNdb7R3AXLTWgoxKucjxtFyRntetI8YSd7dEYhxOwZ40u2jHvhjEPpvlPk19HVKTStJz01Mee1IJPRZjtG4Qsr2hUjOWkXXq9HeGkhe7hhk8h/uFo5Vrap2EliRwRjd95cHnjXaexKJClzlwslpkjCW0l0tymH7aB/vzKxn6LDEn3Lhv18Y+TGwZsJzIxC5or8CpznjKE0MeQxyT2h1mp6HIw6S14DfBqFfsh1rAo8j965S96GPKDPNy0ibwahQKM5IpH3jOQ+//9LawO/HrLCo/WfXvG3PP2oVFi1QbdaqaBx1SMEVyMJxC6O9HYLQf7KccfQ1aiGpY619D9HfLee1RS5Ea+2NyAK+T5NJ3Nta+wKwtlJqM0RkdjRSbv4Pa+3TPTC+nNJEk3mcEFlhX90Dx1wHmeTiq/LhSPuvinGr+cfcA6O9NYz2rkPCKV8iq7ZLXbjlJSRUGl8xzyahf2cQ+jON9k5AQjalzvs5VKGfsPMebm20tyQwrMBY/ApnHK6CfLZXneE8EcmVG4p4obZBvMcbu0XABSSHt6Jw3JpIfl/ha7ZAQnLbJ7xv1ZSPsCRQ78KNmbsG9APuRASO4+eCImbQO6HlSaS35SypnVZAgFRSxiWn6igzLy2O8zD+CfkdC4O05xjtvRiE/hOV7DeFvZDzsnDCU8j3sgNy3/mO0d6pSDTiZIq/3zq6L5ezEGeQzp1Vx51XLMueh39Mw8ivDIU2YM7N0xofQu5JSRJfI5FrazOjve2Q/NCk6tdZwDyXy/p3ZFHagKiE/MBob3tnJJfLecj3OIrk+9BC4KgMns2DSG7CENG20przt0OiESMANpsyi5uefY0/37nEkJumjWXRgqLYfpTvfRHdvKfXjH6iw9gfKdtoVEpNAmZZa/9prU1MTM7pdRYiN+r4VR9S/kSWlddJvgkvQAy5qmC0tzzSkmxx5PMtgaQ+jEfka/6M5IqsS0cYbCESEkj04gWhf7WrtE3L71uI5El2txCmkC+APY32jkImitsRHbU7kIT7KOzb6kLLP6OzcdKATNTnIKvYDUocaySwD8W5iMOASUZ7yyeEwt9AcqA6MWJU+8Ibn32tKoLjfZEg9F8z2jsT8cxGna0scFyCh/5aZKJP+j7mIsVY5TANKaIZTcdiZy7wU93YHBfSL5eNEM9Q/B7QAByDtFjEaK8REZTfEokKXRyE/ivRi4321kI+x8bIwulq4OxYbucKlM7H0+75XyAeyJ/Rka4UIt/z95MWUBl5kILPe/O0Rt77Tz3eUR+FK49b8MnQYfYB4KwZL45sRXQO04iMo2nIIuJkOt/b5iLdUqzR3vmIBz86B4a5x7XAOkZ6nY8H/lsq3SQI/XecusKdJHfPaUPubeUSSRGlsstBn6xD7PxYakwbOx/0qX3n9XoV3JHWRIz1Moyjb9Gd9hM5JcnSe3o64prP6TvcRrJxmHk1H7Y0lXUuuGq9v9A538YiBteVzvNREqO9BqO9U4z2XjPa+7fR3kmuuKaQ44lpDrr/H2i0N9Z5G7cCLkdCOV8iVaZXkC5tAyILkiRvEyIyLTtXWavsEqQ6fGsk5+wiJGdobTo+W+StuZpk3b0hwB5Ge9Mp7VWA9Gt6EaLTFucUsJ0MluEN7Rx2+vtDRy/V3mtdT9Iw2lNGe/XlnFdZCUJ/GrLoOAUpUGgKQr9TFbvR3jqIIZ7kZVyIpOv8sZzj6cbm94H1EUmgmUio0tONzZmqiWMsQXI1u8L93ns37r7GsPrwzSFDw1OAzZS2ByllX3AeNoz2vo14OiciRsgySMgzrhv6LGJIdYVy+zsK8eyfihhkqweh3+1CySD0ZyNGfCswB1Tr9LuXnH+UWeu04SvPXE43Nh+iG5vfDUL/E/e6uYjHMI0JSM/qaAEHcj85C8nvBfGkJi0a1nRpIS1IisAbRnv3GO2leaUJQv8dOqd2FdIGbFhirHFKSS61AR/uuN+nn1lbnF9aN8SqxUaXrN/qTjFgTRkoHWH6IlnC059Q3FYup0YY7S2HeNVORdT8Q/eoA/brQq8L+MpQ/BEyYS4ZtjQ1A8frxuZSTdFBwp8XI4USw4D/IB7BN4DPnPbhJSmyFhpZSW9AhwF0NrCD0Z4peM9Ekj2a85EQ+QdB6M822rsS8bZMoiPX9pdGewcEoZ9U5fsvJPcq8hSATCp3B6Ff1SIuF34+nM4pBKWMn3rSc+0WR4zkrpiPnANJ310neYcPX1y3/pBTl9jo2WDx2e/OrG+YO6eOZccuYv8ftbDdXp8PATYMW5o2RCbQHyKekX8AF+nG5h7NbXRG4rGIp2hJ4EOjvZuQJPN1kLZ05yD5nhXPAE6up1Tu31YlnvtDEPqZOi05w/HYLO/pgudJ/q1bcXI8K6654OF/PTuywYZy6tlQKaBeKfsHlw5xG8Xn5XBgW6O98UHoR+fNo8iCZ0NKL16GIzmaIIbj34AtK/md3HmwG1LtPBS4BVGIeNBobwWkeK4BeDAI/ffi7w9C/wF3r5yGCGGnUShIvghZGD9csG0OyZJgQ5Hfs4GO72R7ZGGwnzt2E/BGzAOZlrM4hPT2gUmsVeK5mcCUc3+w6k0//e07auECTV2dZeTi4oazobIvPrkYJN+T5iKh9P5JmLsae4osRuPjiKRJTg0x2tsE8W6sjlzszyI5axshN7v7yjEYHecgIatoVdwE3BW2NE3Rjc1Ppb3JiWj/wIVTd6Vza7GlEY/dEORGHWd7pF9w4aQzApEn2MJo72lEKPg/blv8HB2G0ywz2jsPMWbiq+g64HdGe88hBvFuyILnNcQIiCYvi4Tbz0WKVqrN5mRL+ldIOHsUxbma5XjaWhFph1MRb+uwgu0/LAw1hi1Na/7uohVfmn7PkiMWzlcoBcOGW3Y+8BO22+urOStEfq/TkO94KGI47h+2NE3Wjc1/y/DZsnIc8rtE5+ZYRCInYiVk4TKa5POsWnxM8m+4ABEGLxujvSZkkn+1WgVFbuF0EqL9WI94y1qRwqvrw5amse/MWHeNyGAsxFpGIyklaWkICrlWZ7hjha5Y7QQkl64e+V2SqtAjGhAjc0tkDsnK1YhEVXQeTAT2cRJEyyK521sBxzqP3+8SjNNWpBtTGvEvZ6jb75bA50Z730E8pueT7MmPG9D1SG5nO+LpXIAUJ90LHOiuw19TnCfbjhiXr8FXRW/nI9/fe8DUBN3IUl7Ji4A1//rw4hMO32otPv1QfqZ1Nmnl2AveQ6EefHtGw8bI/bceuV+0IQvPC+nPucy5zdhjKFumm1YpNQ54Drl4zu6qcXZOZ5QSjfru9Ll0UhP/ofOquA25oYwrRysuImxpakBWu0k5So/pxuZtSoxjJUTAdEc6BHzjfAEsE4R+uwvxTUOMW0uHkG0hFgkvr0GHVE3U8ziiDTHyJiH5Qw+njD9iFh05gWnMB1YOUtrpdQejve2REF+8rVoai5Bcp70pL3Xkf4gI8bru75lB6P+f0d5YJBwYJfj/Mi5Y/uKdG71yxgGrrbtgfufDKGU5+rz/ssuBn4FMtjNJnpie043NE8r8XJlw3qWPkQVIV8xCzrMeuR85qZ3/Id7OwvO8FVirHL1BIx2L7kSUARYiBvjDwN5JepCx945BPGQbIQVeVybJWhntbYpU3I9BcnpvDEK/NWxpmnzQZuMf/eDt4VlSkSLagG8EoV9UWFZw3GMQAyMqjkvyei5CqpQzGfdOS/N5io2yuYgH/3JkgVVXsH1aEPpTY/sZTpnyNSnMQu51WbRU2yhuGToPqS4/0Y3rFMSTvgD5DP8Ftg9C/12Xez2dzve3VuCEIPSviTYY7T2DyOokcQSSr3xMYTRcacvQYZaFC9SxWHUV0klpWeS7no9EcbrzfX1FNea9So63/fpdi3g8/JI0jeqtsQ0UshiN1yOVmROR0NBLSB5HfAfWWluVFnYDiSoZjT9B8mziFdOzge8Eof9I7PUbIl1QhiGhqiejVXjY0rQq8ArJuVof6Mbm5VPGMBIx3MaQ7qGADhmRJZCQ1iiyi8cudI/C3MZIb3E64g0oNRm20bU3fS4iTF5uMUPZGO0NQYy5Rrr+7BZJNwgRT2s5PBaEfinjvgnxQE1GJoPrgVO/d2LL6o/eueTMD98bppKGNWRoyKGnfbBo852+fG7pxkUT6+oSxx4CQ3Rjc9WTg5yhNpfyDOd5yH1pLpIz+hnwYjXzUl3hwn2I4Rgi59W+8eutxPt/gxRfFV638xBR7J/EXlsXLf5c8dRldHwPi5Df8WLgLSSqUDKUGbY0rXzfDUv/59pzxg5dMC9zXVMILB6E/lynAnA84rX/BEk/ecCNcwnEqz4JCUfH7ymzgcOD0C9qClEKo73jELWA+P3OIvPPuhQvCOcBy7m8x2g/itK+p7T8woi5iD5eVx3RCkkqUAQx/EZF56fR3lJIhfInFJy3RnuPInnQ8XF9Boxxi/F9EYmWtMLEvZCiwR1TxnhxEPonZfhMmamZ0bje6V2+9uGXJRspNxqzkSU8fVDBvxvdIwlLlfoe5xQxjmSJHY1It3yF0d6Pka4tw93zhwAPGe19Dqw2cvF1n7jrtX8nCM5jkby/NPZGPGddzUCzkTyg8yijwi+FYcjYF9CxYo/+mjL2We75PcTpKo5BEsvnAUOrUOXZjniJbkAMjjgWMQJmIwLJN1Fmf1Jk8rkw7UmX7/U84tWNWrn9GNjv9svGfBKGJBqMAG2LNNefP5arzlp++btee0WNGp04387tCYPRsQBZmI4t47XtSPjy58gCow5430mhvF3OwVwRVhik9B0PQv+fRjoWrY+cky+mvTZh3wqpeo9ftw2It+wn7jXHINXGyxrtvYOcDz+ls+Ex1D1+hvz+Vxjt7ROE/ldFb26hsrMb6xuw/l0PvvfSg+801+/04O+WHhK2Q4ZLcS4iG/Uk8CJyz48+x6ZGe+cGoX8+HYVcLyGGbaERFiLXU6ouaQk+Jz01oFRY/OsUqHu46ueFJBtX0PUXUo/ce9NYgPxOheNJW/CMcPtqdmP7jILcSaO9A5G0jDRNzxHA0q4a/lrSP9MCROJpzxLjztRUoF+RF7r0GFmMxqSqzpze5S+I0TYqtl0hoV3gq/DxVDpPVCORLg3tQN3cWUMm3n7Zsov2OfbjVqU6QiDWMj9s58wSLp6vJxw/TqSjtojyvH2lGJLy/hAxuNIS8mchN9QkIzu+/9MQj2jUUQZgkdHem4hkybbI57kRWZ13GbpxEib3I/p5SeP/N3BYEPrPFrxnc5K7aMRpRSadq432ZiK5TnGd1BOQ3zw+IS7f3qaXowsWLdDtwJg/3rQ0exz2CfUjOm7C7W0srBvCVWWMsyLcJP9TpBK+VPoByMJkGvI5o99ujSWWXfRI2/tNv9CaIcADSd1WnCf2WiRXOzTaux/4QRD6HztDbnXknIgKvb6G5M9t6Iyz3yPewtYS41Okn4ORR+5EpBgs+v8qFBuMhWg6rsHbjPZWCEL/C+cNjHKCR+HCtcfuMG7y5Y+8/r9vbD3r0HO+v8rwRQvL9jhGfcZ/gEQN4veTM4z2vkBy59rc64ciOcdj3Wf/N+KVrSTceQ+xzjwF43qXjmKbQhqAy432JsSO+Qek01NX3uskD+F85LsckzIWH7kvrkd5FvnfjPa+WVBgBIDR3v5IyL3UOR8iqT9TSb9XLAK+HUiv6ceQgsX4uEIGsmxe77cRHDRk6QjT5xpnD0LuAE6nc+XvPODxWN7RjqSHY6IZo+HGX4ytGzEyfHqXgz9d24Ys99aMeq46a4XhLz8z6i/g/R2ZjPdEwiczkRVwOefBMDq6qnTHYCxFO6KnaOiYzDTyue9DDMHnSrw/RFbjnyOr+vhEMRyRxVm7YNvpwBSjvZKVoEZ7dUgnl2VIr0z8VcxgnIKkEJQz6TTQode4EjDRaG8vxLM4202WSUVEEeVYDUPg/9s77zg7yqrxf89NQiqEIC0QJIBAUF+6CEGl6KUL6Ou+vKhAkCIoTX1Fikqo+kNEkaJIC4IKrAVslCWILVQBadKJEEIJAUIgfe/5/XGeyU5mZ+7ce/e23T3fz2c+szPztDn73Jkz53mecxh2zXnjWWvCUnbcax5LFwvDhivPPTby+c22WZCMpVqWYqFjDGYZPQjrH3diztrvTCpdwfK3NSu+FLOGEHuNeHxk7zeHnHjhixujXBjyXVB6ZZMTC2s/dWGsjlUxq3L0sTAEs9D9pVjoOABTBKKQb/OxBTdR/OSIjbGIG9sn51QGpXIvbO7tK5jfwjgKPFa0GOrfpPeQbqVzEEvAxcVCxwRMWVwv1sYxwMhnHx118e7rbLFXYYjeXermPHorP1lDqYL9xr5B+sfZUmzleVJ5iSKLKPa8qGY18HLCIp89sJjQUR2KKX/lFq69D5uWE59y8iKV/bYK2Edv3LPCXzCr3dn0VugEs3QXKiwf7H99Dr2tgGnlx1kEXBSCAKxD9u9YsY/G2+lR5pNtiz4IBiTuUqdxVDSnUUTeiykOCtwXwuU4VVCvuR1hDsy3sPkqi7DVhT/osti0UZpDsC/0PIsg2CrLWdhk6rThnuiFopiC+lvsod3qeSDvYHOaxmMv+3cxx9n/ic0L2g6z9qX5J1yGPeyvJt+alax3v+TCkoiw6OEubHiwHNdiFoCDsJfyJKrzm5pEsf9VNzY/Ks3hczX8g1jovPesvZQJGy3ipeeG8/rLK/2oq9R5fKUFBavdDGxBTVIRXIS9kDfAFJ4Hw7lPUH4BUypjV1vGNfc9nhaLeCGwVWHtp54MbToWc0Kd/N8vJXtxVxrvAId1lTpviE4ES/99mEJaznK8jDA3lL79r7op/yGwDHOHtT69rZ6LMavd6phi3I0pTQCf7rJ45j/HfFUm27gUk1Peh+HL2GKzmsIHFi1837GYIncxNj0mL4LOo8C2XaXOxcHN15ukL8BLoxTSP4dZoq8M587DpptE02b6wutdpc7lz6XwG+mmfL9bhi2EubhY6DgCU9iz/EEuxOb4HoF5Ikgra07YLscWWNV9MVmr5jTuMemkvKTc8oSFcfc5jdWRawUSkfOwr5ZIsCoiP1DVrze0ZU4qYQ7MV8KWxe+oPITgcMy5bdYLOu6AehSwP41VGLuBV0HHgmQ6yMXa/QS2AjV1qVxXqfPeMHybpjQOIX3YJo+RmBUvK2rMBeQrjIuxhQzfwuYZlrvPShF6VpunLmKKEVn2spTleSRi8c59ZRhzX1neRfKG/JNshw3fJRWoaEh539i5XaosewUm7zGPUikK8LICwzDFJ1pZ+37S779aRXUM5s/wN5gPyUnYUHOeE3aonxU+z3I8BFPK0+a/Dccsg2tgSvvumGX117FFNj/CfLMm76lAZcrTeMzlTSXxuVegWOjYH5vfGSlUX8FGXPKYBPw9TPkYSmUf0BEFbOX+E9h85JWxj4MLsP5ZLipTpbwGEFwYHY0p7G9Q3mPAUMwH7fXY1IjjsJGQtP//MszQM5F0S/JQ7P8yHvt42rNY6Ni7zoENWkdpYNxGO1L2oSUiB2J+8BT7AQnmZ+yrIvKAqlb9EHDqS/iK7gAOwf5PV2JWnUqVoXWqSAum4ORZNvrCEGDMjnu+xb3Tx7J0SeJZJwr2YRgtCrihWOgYV2bO1LOYFTXZXsEslNU+XQSzzPYiDEsfXkEZy7AX4UNUr4D1hcha/Fns/34WvV3JgL0ks/rEIkzhrYYPVJm+ZoYMU4KxIUmBFZXW+zFFoBplIo3FmJL1PPbiH0X9fhuL6QmV2VfLVtaCCTC5vIhZ3ldwyl8sdOyHPVPS+mk19/lJqlQai4WO1THlKKmsfpbsIfWIocC22KK+z+WkzWJbbEFW9MxL9qFa6QYeLxY6bsHckI3Efm+VWGKHhjaVsAU0czB/ksn7E+yDdP2Ua0lGYSvft6d8hJn+gw9PN4y8znQ41pE/oaofUNX3Y1+iJXyFdMsJQxo3YHN39sTmUF2NzY1bUiZrnFqshg2NSTz2PUtXOfrM2aPHrNrN0GHxqZnKiFG9pmqOAC4oFjrWKRY6Vi4WOt5fLHSsDMvnlV2AvXzTEKp/mRSASaHsJPuRL883MGvtrjRXYQRTGr/RVeq8qavU+WNsbttVKenKzc/qxvpYNTxB9cp5Tdxz+ypI+n90EfCb2PF1mEW1HvO6DsXmxVbiVaAahmGWor7KrpLf+FgspvPiYqHjW8VCRyH4fvwtFgmlr6MLC4uFjk2K1YWD/BTp8hxWRXs2pjan4mAK4jhM4R5JfRRGsHv6NPYuHUXPvVRieY6mMgwN+TejZ+FhxBJsisoEKrN4g8l04ATvUM3fnJrIe2FuDtykqn+OTqjq7djE5HqY6J0aKBY6xgUfbudgQ2Lx4c3RmGWtnGWh3mjY5mFDn7Pow8t4/PpLeP6JEex2wBtsuuWCYDmyudyL3k19Jx8Z6nwLW/wyp1jomIUpi3eHc/Wcr3MScEvKC/DQCvKOxhaEnF3H9lRKAfhesSfOt1KZA+2IErB3mnPpHO7CFlKVdWRdD+a8tBJXn7s2ixYKy5ZCqRuWLWUp8NN4BJsQ1ehDVBnVJYVIsWjElI0C9VdE8xiG+YKdBtxC/e7rQGy+6sww17gSxlO7m5w41cxZbhZ9tRyDKY6RG6S4PBZjxp5qrOjdwJbFQsd2VSr27Ul3KX9zaiKv444jEa828AQ2ydtpMsVCx5nAXGxC+Elkz4erehFBH5CwRcNzE+jDi+7pf43k7CMncsNFa/LYfaPDR2HucyyyGo7BXuTRiuiVsC/oal1+vFvmWgH4ODYsFGdiBeVGq7IrtQDUmxFAsVjo2Bzz07ZfFXlL9KyMrZgw3PljmvQh8+ufrMlxe21MO6XPLwAAH6hJREFU5yVr8utL1+D0L2xwR2Htp3rNAQ7K72XYkP1Apto3ZAFboFXpwpFKGIk9G94L3FW0EHl5pPk2dfJZGVtBXg0jsMWVdwA3ZYyk9B+0lL85NZGnNBZIt9BEq+bqhohMEJErRWS2iCwWkZki8kMRqerBISKrhXwzQzmzQ7mZUTbqVXejCcNF36T1K5cbSnd3gUULhmCL2qKtTwyn+qGlShannJg4fq7CsqM4r61iE8wdR66/xgRDgauKhY4bi4WOfcN82lzCiv/LaGK//c+TI5n2/8Zz+VnrdN87fZU/pbRpw2Kh4/tku5MZSNTDqlVPCsDfghumVIqFjv/FVkw7zUGwZ9Jo7IO4krnZ7YsPTzeMSh4mDZeuiGwE/BMb3rsXcyXwHBa26i4RqWgILaS7K+R7NpRzbyj3nyKyYaPqbhJntLoB/ZhGKGnJqA0/qiJvK1/kS6ndijQEs07eAPyqwqGsc2ndh84Q7FmwnGKh41LMYfdXyY684TSWYViIwF4ULXb6VTR3WN7pYRTmqqf/UtL8zamJSl5cU0WkO75hQdZJng9bLb64LsEm5R+nqvur6kmquiumwG1K5fO/zsGsKOer6sdDOftjCuCaoZ5G1d0MVs9P4jSRvyeOF9OkBR995EL6Pql/OLZQ4awK0m7ex7r6ytWRVTS4ODmSAW6t7yfsm3G+g+YvEnNWpH9b393S2DAqURqlyq0qC0qw9O2GhZ66OHH5NGxu2UEiZX32ISJjsHk472ITueNchEUm2D1ubaxX3U3kmVY3wFmBkxPH2zP4lJFvFAsdac6D4zybc73RrIy5FAH7XTvtwcoZ5/dqaiucNDYtFjrqOae1ubjS2DDKKniqWqhlq7INkTPf21RXnJ2qqvOxyBSjsBdyObbHvo7+EfLFy4l8WsXrq2fdzWLH/CROE/lt4rh/zwOqjSHAmbEV2Wls06zGZDCMHiv9B1vZEGcFshYguWeO1lMAzm91I2qmuzt/c2qiHSZIbxr2T2VcfzrsN2lAOX2qW0SmiohWsuW0vVJ8eLq9SLoOyVxsNcDJi0KTZVFqFlEYQ2hcLHSneh7NOO//o/ag2OoG1IxbGhtGOyiNY8N+Xsb16Hyei59ayqlX3c2inBsYp/m8lTiuNlLKQKGARabI4tpmNSSDhV2lztnh75da2hInQrHwdWlkheh0mktq5Kt+gSuNDaMdlEanco5vdQOcFUjOvRqM0wcWA1cGZ9lZnEj1vgLrSdwX5Zda1gonzqVdpc7pGde+2NSWOFl8vdUNqBlfPd0w2kFpjKx5YzOuR+eTVp16lNOnulV1qqpKJVtO2yuiq9T5M6CrHmUFlmHzivryC6rWaXZa/mWY8tGfPK5e0VXqfCR+oqvU+Ta2gn+wsARz2t3LcXac4Nx7bVpj5ftDV6lz+W+mq9R5B9ZmpzUsAr7QVeo8OitBV6nzTSxWdT2jODmVo8CpXaXOGbkp2xTVUu7m1EY7zB15Muyz5ixuHPZZ8w77Uk696m4aXaXO3YqFjrHYJOWF2HytBdgK8GXYPMwS8L/YIp57sZf7JCxk3B1YmMFru0qdfw8OdtfBXupbY6vMP4wp1POBF4C3Q10fwsJNFbHwa1dgER4ew75KD8Pc0JwZ2rQN8Fqo+wVgq5DvMcyx9CPYsOYHsegP92OLFvYA3gS2xWT/IvBqaNtqwGexyC8LMB+bW4Z2RM6C/xDucyvsxTMCU0qHBZkcH+7tkVDGWti8vNeDLJYBGwDXYEr6heG+52IvvTO7Sp2pT52uUuepxULHN4MMotjOBeCQIOPvhvLXDXU9H+T9L+DhcB87h7ZvhjnhHoIpXKOD/F7H+uwY7P/+IawvfzjI/x5gnyD/+0O6McADQaZgPiWfAT6POfN9NMikhH0svQHcF+rZLbTvQawP3RfuYV5XqbOi0IBdpc45xOZ8BufNO2FTLrrDvb+K+dPcCngZi7CzEPsdPoT9X9cHDg73+W6QzXDMt+rC0N4vYX3mkK5SZ6/FFl2lzi8VCx1fxfw0CrA39n+dgfWXdbAX58+CTHcJ9cwK970h1mcO7Cp1PlksdByPzW99GbM2vxzkuAyLzPFAyDsq1PV34K9YX94C+wC5p1jo+DbmL/atIIvrQr1PYv+/EcBHsd/GPiHNqCC7XbD/50FBzsXQjs2xBYK7hnJexCJ6rYv1x02w/jIZ6wNbYL+zI0IdF2P97WnsmfAB7HewBPtNPxHa9UGs766H/a7Ghrafi62eHx3yPB0+IsrSVer8Q7HQMRx7Vo3CfjfDsTjS64T2dGN9Euw3tib2PFkdi3a0Q5BhCVNC1wt5dgzlSJDdKtizYY1Q1uQgg6XAv+n5PSzB+thW9PSVyKfha6F93VifeS20aVaQ1xzs97gQ+CH2XJmETX06NaR5JLRlJax/PBbaehL2v3sw3MMToV2/x/6/v8T6xCKsT8wO9T+APRv2w34rN2H/wyHYb2tD7Pf0/ZB/YijjN5X+rtsWDxPYMERbPLYf3N48g738NoqvYhaRlbEHnwBrqmrmEFhwufMa9oAYH19BLSIF7ME1MdTxXD3rrvA+FaBeVkfHcRzHaWea/d6L6tt9lUNz09769lWAv5OrpeXD06r6LHAbptB9OXH5dOwL9Zq40iYik0RkUqKcdzDL0Gh6+2k8JpR/a6Qw1lq34ziO4zhtjC+EaRgttzTCcovfDGx44SbM9B4NCz0FTFbVubH0qV8vIeTfDGzI5Q5saHYzzDz/Wijn2USequruwz26pdFxHMcZNLTK0rjb6INz09727s8AfydXS8stjbDc4rctMA1T2L4GbARcAGxfqdIW0u2Azdd6Xyjnw9i8sm2SCmM963Ycx3Ecpw1ogaVRRCaIyJUiMltEFovITBH5oYiMq7Kc1UK+maGc2aHctvAD3BaWxsGAWxodx3GcwUTLLI0jPp+b9rZF5j62Hm1LGbF8Alsctwu2iGnHSgxQKaOl92ELpqLR0h3iU+xaQTusnnYcx3Ecx6kL2vwwgZdgCuNxqnphdFJEzsdckp0NHFVBOedgCuP5qvq1WDnHYaOfl2DeRVqGWxqbhFsaHcdxnMFEqyyNxaEH5KbtWnY90Pe2NdEDzHOYi6SNWmltdEtjk6ljHGrHcRzHcRJECmElVPlOPl1VpybO7RL2t2nCa7iqzheRf2C+brcHsqIgEa6PDOXMj19Q1ZKI3AocGeprmdLYFgthHMdxHMdx+iGbhn1WEJCnwz4riEi9y2kobmlsEgNxWDr+hTYQ768euIzK4/LJx2VUHpdPPoNFRtXem4hMBU7rY7VRuOF5Gdej86s2qZyG4kqj4ziO4ziDjjDUPLXFzehX+PC04ziO4zhObUQWwLEZ16PzbzWpnIbiSqPjOI7jOE5tPBn2WXMNNw77rLmK9S6nobjLHadmBss8mb7gMiqPyycfl1F5XD75uIwaRxNd7jwLTKTFLnfc0ug4juM4jlMDIRTxbZhC9+XE5dOB0cA1cYVRRCaJyKREOe8A14T0UxPlHBPKv7XVEWHc0ujUjH+95uMyKo/LJx+XUXlcPvm4jBpLShjBfwMfxnwqPgVMjocRzHJ6nhJG8F5gM3rCCE4OSmrLcKXRqRl/EOXjMiqPyycfl1F5XD75uIwaj4isB5yBhfl7DzYs/VvMIfibibSZkXJEZDXMDdD+wHhgLnAz8G1VndXIe6gEVxqdmvEHUT4uo/K4fPJxGZXH5ZOPy8ipFz6n0XEcx3Ecx8nFlUbHcRzHcRwnF48I4/SF01vdgH6Ay6g8Lp98XEblcfnk4zJy6oLPaXQcx3Ecx3Fy8eFpx3Ecx3EcJxdXGh3HcRzHcZxcXGl0HMdxHMdxcnGl0XEcx3Ecx8nFlcZBgIh8RkQuFJG/icjbIqIicm1G2vVE5BIRuUdEXhGRxSIyO+Q9VESGpeT5mIhcIyKPishcEVkkIs+LyO9E5ONl2jVSRE4XkSdDntdE5AYR2aye959Ho+WTUsbwICsVkUwP/yKymoj8UERmxuq5UkQm9OV+a6EJfWhKKDNrOyqjrkHVh0RkrIicISIPi8g7oa5HReTSDLm2hXxCWxrdh2bm9CEVkW+l5GsLGTWjD4nImiJybugz88We1/8Uka+LyMoZedpCPk574KunBwEi8hCwBfAOMAuYBPxcVT+fknZnLHbmPcBzwBtYSKQ9gfWAPwO7qeqyWJ6pwBEhzyzgXeC9wL7AGOAsVV3hYS0iw4HpwI7A/ViczfWADmAJsKuq3lOP+8+j0fJJKeP7wJGYbF5S1V5KoPSOQXpfaFcUg3SHZgaub0IfmgJcFfI9lNKEP6jq/Yl6BlUfEpFJwG3AusDtmJyGAROxGLfrqeo7sfRtI5/Qnkb3oROAVdOqBk7BXMx9KN6P2klGTZDPxJB+TeBO7H5HALthz5mHge1VdWEsT9vIx2kTVNW3Ab5hL5SNsYfnzoAC12akXQkopJwfhj2IFPifxLURGWWtC7wKdAPjE9dODmV1xuvDlCIFHktrR3+UTyLdzkAJOCqknZWR7tJw/fuJ88eF87cMsD40JZyfUkWbBk0fAkYBTwFvYi/2ZN6hBCNAO8qnGTIqU+/uIf0Dg7wPXRzOn5Y4PwRTDBU4uF3l41t7bD48PQhQ1T+r6tMafu05aZeoainl/FLgxnC4ceLaooyyXsKsZQVgw+i8iAimNAGcGK9PVW8C/ga8H9gpr731oNHyiRCRVYBpwHRV/UlWHSIyBjgIs9hOTVy+CPgPsLuIbEiTaJaMKmUQ9qGjwrmTVfXulLzL4nW3m3xCva3qQ0eG/aXxk+0moybIJ3pe/C6Rpxv4YzhcIzrfbvJx2gNXGp2KEJEhwF7h8OEK86wJfBhYDDwZu7QRNnz9lKo+n5L15rDftbbWNp8K5fMjYBxwWE5x2wMjgX+o6vz4hfDgvjUc7lJba1tDhTLaUkROEJGTROQgyZ6/Odj60Gcxy851IjJRRI4WkZNF5HNhKkOSAScfqP45JCJrAZ/Ehnx/kbg84GSUI5/Hwn7vRJ4CNqxdwoafIwacfJy+42EEnVREZHXgGGyoZA2gCLwP+IWq/j4jz7bAPli/moA9rMcCx6rq67Gkm4b9UxnVPx32m/TlHhpJtfIRkU8BhwCHq+oLOcX3e/lAbX0IOD5x3C0ilwMnJCza/V5GlconLGrYApiDzR0+hxWf3e+KyHGqemXsXL+XD9Tch+J8ARuynZb8AGMAyKhK+ZyLPZ/PFJFdgAewYe7dgLWxZ9ODsfT9Xj5O/XGl0clideC02LEC52ETyrPYNpFnPnCoql6TSDc27OdllBOdT5vU3i5ULJ9g7fgpcLOqXlFB2QNBPlBdH3oeOBZb6DELk8FHgO8AXwRWwaxtEQNBRpXKZzXsWf0eTB5nAFcCC4H9gR8Cl4vITFWNLEUDQT5Q23MIWD68eng4/GlKkoEgo4rlo6qvicj2WN/5FD0WQgUuwxZXxRkI8nHqjA9PO6mo6hOqKtjLan3gK9jcoL+KyGoZeX4S8ozE5rpcBfxMRDLn7/VXqpTPZSHd4QwiqpGRqv5FVS9S1adUdYGqvqyqndgQ/JvAgSKyRbPvoZFUIZ/oOT0EuFxVz1DVWao6N3yEnIJZmr7RxOY3hVqeQzE+gc3je0ATK+8HCtXIJ6ye/ivwX9gQ9lhgPHA08DngPhHZoGmNd/olrjQ6ZVHVblV9QVUvwCw+22OWjnJ5Fqnqv1X1eGzy+RdF5DOxJNEX6tjeuVc4/1Yfmt4U8uQjIgdjw/THq+rsCosdMPKB2vpQLO+LwJ/C4cdilwaMjCqQT9zS89uUIqJz26Xk6ffygZr7ULQAJs3KCANIRhXKZxqmMP63qt6sqm+r6iuqeilwKrAWK1otB4x8nPrhSqNTDdHE5537mCdaFJM1FyZa9Zc1l6ZdSbvXrcP+akk4Gg7n142di4Z5Bqp8oLY+NCfsR8fODVQZ9ZKPqi4AXgyHaS/oN8N+ZOzcQJUPVNCHwiK8/UhfABMxUGXUSz7BcfdOwBuqmraA6M9hv03s3ECVj9MHfE6jUw3rhn2m4+oK8zwLvABsIiIbpKzM2zPs76B/kXavd2FOvNM4DFgA/DIcLw77u7H5ajuKyMrxCfxhpeNu4TB60PcnaulDHw77uDPzwdSHwOabHQp8EHPQHOeDYR+XwUCVD1TWhw4lewFMxECVUZp8Vgr7VURkJVVdksgTudqJnx+o8nH6gFsanRUQka2D24bk+THABeHwj4lr2yXTh/Mb0TMhe3me4Icsmud4blCEojz7AR8FHgf+UuNtNIxq5aOq16vq4WlbSPJm7NzCkOcd4BrMsjY1UdUxWASQW7WJEWGqocY+tG1K+oKInAzsALwO3BJdG0x9KHAx5hLlJBGJ+9IbAZwdDqOPj34tH6hZRlGa+AKYS9PSQP+WUQ3PobnAvzFDUTI61wjgm+FweixPv5WP0zg8jOAgQET2x1ZZgrlW2B2z2vwtnHtdVf8vpL0RCxk1A/vKXICFjdoTWyU3A9hdVwxX9hYW2u5BbBhtKObja4/w94WqelyiTcOxL9TJWHiq6ZhPsFaE72qofMrUq1QeRvBeYDN6wghOVtVna7nfWmhCH1LgUeBfwEvYfKkdMSvaAuBTqnpbok2Dqg+JyLeB07H//++ARaGejUOej8fdErWTfEJ7mvI7E4t3fzu2AGab5PVE2raRURN+Y5/AFMmVMGv1DGxKw57YIppnsGhDc2N52kY+TpugbRCWxrfGbpi1SstsM2Np9wauxeapzAOWYi+p27GJ5UNTyj8O+AMWqWQBNsz6AhZ6avcy7RqFTdZ+OuSZE/K8fyDJp0y9SkYYwXB9Ncxq8B/sAf0y5i5jwgDsQ9/DLBazMWVoAfAEFgFnQ+9Dy/N+GlsB+3aQ02PYIobh7SyfJsvo+lDeFytsV1vIqBnyATbHRjFewJ4pC0MfOgdYtZ3l41t7bG5pdBzHcRzHcXLxOY2O4ziO4zhOLq40Oo7jOI7jOLm40ug4juM4juPk4kqj4ziO4ziOk4srjY7jOI7jOE4urjQ6juM4juM4ubjS6DiO4ziO4+TiSqPjDBJEZGcRURGZ2sdypoRyou2W/FyOUzki8miij+3c6jY5juNKo+OUJfHiqmSb0uo2N5GbsLB218ZPpiiV0TZfRB4QkVNEZFSyMBGZlibD2Plo6xaReSLyrIjcKCLHhLCLDUdENhaRb4jIHSLyoogsEZFXReQmEdmlwjKGx5SiWRlp7szpZyMS6adW0DdTw06KyD6hvnki8o6I3CMih+TcwyEicm9IPy/k36dM+iEi8hUReVhEForIGyLyJxGZnJHlEqxveVxjx2kjhra6AY7T5pyecu4ELDbyBcBbiWsPNbxF7cONqjqtzPV/ATeGvwtYPN1PAmcDe4jILqraXUV9N9Ej35WxWLsfxeJxny0ix+e0px6cCRwAPA78CXgD2BTYF9g3tOFHOWWcg8X6rYS0/gewLHF8Z5kyPglsDdycvCAixwAXAnMx5X8J8Blgmoj8l4ZYx4k85wFfA2YBl2GxjP8X+L2IHKuqFyXSC3BdKPdJLDTkapgc/yoi/62qN8XzqOolIe9UYKcy9+Y4TjNpdRxD33zrbxswE4sFO7HVbamy3TuHdk/tYzlTQjlTcq5PS7m2Khb3VoGdE9empZWbdT5cG4rF2l0Y0hzYYBlOAbZKOb8TpnAtBsbn/A9KwFGUiT2OKYFah/YOAV4MdW2euDYRi189N96XgXHAMyHPDok8k8P5Z4BxibLmhvImJvIcGPL8AxgRO/+hIK/XgJUz2j81ra/45ptvrdl8eNpxGkBseHG4iJwlIs+LyOIwpHqaiKyUkW9SGI6ND33+QkQ2TUm7iYh8V0TuF5E5ofz/iMhPRWRCFW0dISK/Cu29WEQa9lxQ1beA+8LhGnUob5mq/hT4Ujh1voiM7Gu5ZeqbpqoPppz/C6borYQpVr0QkVUwBXi6qv6kUW1MsBcwAbhbVR9OXPsCMBy4SFVnRidV9U3MGgqm3MaJjs8O6aI8M4GLQ3mHJvIcHfbfVNVFsTz3Addj/eAzVd2V4zgtwZVGx2ksN2Av599jw3KKWU9+HYbtliMiewAPAJ/DFKsfAtOBTwP3isjWibI/jb3EXwR+iQ0zPg4cDtwnIuvmNU5ExgFdoayTVfXLqlqq6U4rQETGYhamEtBL+eoDVwP/wYbAd61judWwNOyTQ8cRP8KseIdVWqCIHCAiJ4nIV0VkTxEZXmWbjgz7n6Zci+SUtpDp5kSamvKEuZeTgQXA36qox3GcNsTnNDpOY9kM+EBklRGRU4E/A/sAnweuCefHYYrfAuBjqvp4VICIfBC4G7gcm5sWcQ3wA1VdHK9QRHbDXsbfpMfK0wsRWT+kex9wkKr+vE932pstpWeldgFYC7vvscBxqvpMvSpS1ZKI/A2bK7gd8Md6lV0JQZYfx/5/f025/ingEOBwVX2hiqKvSxy/JiJfVtVfVdCmCcCewDzMopcksl4/lbygqi+LyLvABBEZpaoLRGQ0sC7wjqq+nFLe02G/SezcRtgQ+XOqmqZMp+VxHKdNcaXRcRrLmYlhvEUicjKmOH6BoDQCB2Pz/Y6JK4whz6Michlwgoi8P7quqi+lVaiqt4nIY8DuWY0SkS2xhRyjgT1VdXrNd5jNFmFL8kvgjgbUF8mjz8Pe1RCsfz/HhmZPjP+/w/W1MEvfzap6RYXF3gSch1lj52LK8CHYApTrRWRvVc1zdXQYprBdq6oLUq6PDft5GfnnYf1jLKYMV5IerB9XU0cyj+M4bYorjY7TWNJchvwd6Aa2ip3bIey3kHQ/ipElZjNsCDpalfo5bHHGFtjQ55BYniUZbfoI8FVgPmbV/FfeTdTI1ao6JToIytMnsFXn+4jIzqr6QB3ri4b7NTehyAn0VlRuVNWqVr+LyBBM8d8Rs+adl5LsMuxZe3il5arqDxKnngROEZHZ2DSE75A+RBy1q0DPMPilldbrOI5TDlcaHaexvJo8oarLROR1YM3Y6cjP4BE55Y2J/X0+5v7nZeBWzNK2MFybQrZbl60wlzUzgCdy6qsbqvoq8POwUOUyTPHJtIbWwDphP6eCtCfQWz4zqcJlUlAYrwU6sLmrn1dVTaQ5GHN5c4iqzq607DJcDvwAG/pfWVXnZ6TbE3NJdLeqPpKRZh6wOmYNnJtyPWklnJc4n5U+7oaqljyO47QprjQ6TmNZC3MxsxwRGYq9rN+OnY5erlukrHLthYisCRwHPApMTioPInJgmewXYQrrUcDvRGR/VV1YJn29uSfst6tXgcGy9rFE+Zmo6sQ+1jcMG5LuAH4BHKzpPiejOahXi8jVKdfXFZFI0RwXVpdnEqY3zMesyqMxa3Ea0QKYclbGJ7F+uAlwV/yCiIwP5c+KhrZV9V0ReSm0eXzKvMaNwz4+R/JZzKq+oYgMTZnXmJbHcZw2xVdPO05jSXNM/BFsGDm+evjusP9oheVuiP1+b0tRGCeE61moqh6Nrc7eDfhjWOTQLMaFfT2fP1OA92JW1z/XsdxeBHdJnZjC+DNsEVGWk/K7gCsyNrC5gtHx4rQCEnVvislvPvB6Rpp1gL3JXgATEc0r3SPl2p6JNDXlCS52ZgCjSO/bWfU4jtOGuNLoOI3lW2FlNLDcBcl3wuFVsXRXYUN0p4lILwuciBRkxfi7M8P+I2GYNEo3hp45dGVR1a+EtuwC3Br8CDaU0Nbjw+GddShvqIgcgfkIVOArcV+A9SYsevktFoXmCuDQci6KVPV6VT08bQtJ3oydWxjq2EBEVkupew16+sx1GauRoWcBzDU5FuSrMEX1GBGZGKtnHHBKOEz6k4yOT03064nAl0N5VyXy/Djsz5JY+EMR+RAWFWYO8Osy7XQcp03w4WnHaSz/Bh4TkV9hfvz2w9yQ/JGeldOo6lwR+QymkNwtItOBxzBFaD1socx7gBEh/Ssich0Wvu0hEbkNmx9WxKJyPARsmdc4VT1FRBZh4eq6RGSP5OrfPhB3uQM2JL4r5urldeDEKsvbP6bcjMYsix8FxmNWtSNVtZxlrR78BHOY/To2h/TbCXebAHeq6p19qGMn4Cci8nfgOSxU4XtDvWOB+8mQXWIBTJpvxuWo6vMi8nXMf+T9InI9PWEEJwDfV9W7EnlmiMj52EKqh0O/XglT/lYDjo07Cg9ch/kB/QzwoIj8HuvLB2DK7RGq+jaO47Q9rjQ6TmP5H+Bb2CrndTBFYyrw3eSiCVWdLiKbA/+HLRD5KPYSn40N3yWtMYdhSsUBmJVnDvA74NspaTNR1TNEZCFwLjBdRHZT1dShzypJutxZhFlILwDOTVkYEllMs1Z97xe2EvAudr/3ArcDv1DVN+rQ5jw2CPvVMTlncWcf6vgnpmhtgy1aWgUbjn4EW3BzqapmyWh3bIFPuQUwy1HVC0VkJtbnDsZGnx7HorekzcFEVb8mIo9gfe5I7P/xAPA9Vf1DSnoNc2xnYG6mjsX6wl+Bs1R1Rl47HcdpDyTx3nIcpw6IyJ3ATqraywzV3xGRKdgQ5KGqOq2O5d6KzbEsqurt9SrX6b8ES/VpwC59tN46jlMHfE6j4zi1clWIV53nZDqX4MNxMjaE/88+t8zp14jIo2FV+WmtbovjOD348LTjONXyEDYHMqLmcIAisj/m8Ht/zAflRXWcU+n0Xy5hRT+mM1vUDsdxYvjwtOM0gIE8PF1PRGQacCDwPLYw6Ltl3Nc4juM4LcSVRsdxHMdxHCcXn9PoOI7jOI7j5OJKo+M4juM4jpOLK42O4ziO4zhOLq40Oo7jOI7jOLm40ug4juM4juPk8v8Bn3kIMP/0TQ8AAAAASUVORK5CYII=\n", + "image/png": "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", "text/plain": [ "
" ] @@ -975,7 +952,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1011,7 +988,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1070,7 +1047,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1096,22 +1073,15 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 1/1 [00:00<00:00, 1.29it/s]\n" - ] - } - ], + "outputs": [], "source": [ - "cnn.predict(modelname='/Users/arcticfox/Desktop/results/ensemble_s0002_i0050_b0.73.h5',\n", + "from stella.models import get_model_path\n", + "cnn.predict(modelname=get_model_path(),\n", " times=lc.time, \n", " fluxes=lc.flux, \n", - " errs=lc.flux_err)" + " errs=lc.flux_err)\n" ] }, { @@ -1130,7 +1100,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/getting_started/tutorial.ipynb.bak b/docs/getting_started/tutorial.ipynb.bak new file mode 100644 index 0000000..5980c8d --- /dev/null +++ b/docs/getting_started/tutorial.ipynb.bak @@ -0,0 +1,1155 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating A New CNN" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hi! Welcome to $\\texttt{stella}$, a package to identify stellar flares using $\\textit{TESS}$ two-minute data. Here, we'll run through an example of how to create a convolutional neural network (CNN) model and how to use it to predict where flares are in your own light curves. Let's get started!" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "sys.path.insert(1, '/Users/arcticfox/Documents/GitHub/stella/')\n", + "import stella\n", + "import numpy as np\n", + "from tqdm import tqdm_notebook\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.rcParams['font.size'] = 20" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 1.1 The Training Set" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For this network, we'll be using the flare catalog presented in Günther et al. (2020), which were identified and hand-labeled using all stars observed at two-minute cadence in $\\textit{TESS}$ Sectors 1 and 2. The catalog and the light curves can be downloaded through $\\texttt{stella}$ with the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: AstropyDeprecationWarning: ./Guenther_2020_flare_catalog.txt already exists. Automatically overwriting ASCII files is deprecated. Use the argument 'overwrite=True' in the future. [astropy.io.ascii.ui]\n", + "WARNING: Logging before flag parsing goes to stderr.\n", + "W0714 08:45:08.602910 4409996736 logger.py:204] AstropyDeprecationWarning: ./Guenther_2020_flare_catalog.txt already exists. Automatically overwriting ASCII files is deprecated. Use the argument 'overwrite=True' in the future.\n" + ] + } + ], + "source": [ + "download = stella.DownloadSets(fn_dir='.')\n", + "download.download_catalog()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Et voila! A table of flares. For this demo, we'll only be using a subset of targets. Please ignore this when creating your own CNN!!\n", + "\n", + "And we'll download that subset of light curves." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/5 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ind_pc = np.where(ds.train_labels==1)[0] # Flares\n", + "ind_nc = np.where(ds.train_labels==0)[0] # No flares\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(10,3), \n", + " sharex=True, sharey=True)\n", + "ax1.plot(ds.train_data[ind_pc[10]], 'r')\n", + "ax1.set_title('Flare')\n", + "ax1.set_xlabel('Cadences')\n", + "ax2.plot(ds.train_data[ind_nc[10]], 'k')\n", + "ax2.set_title('No Flare')\n", + "ax2.set_xlabel('Cadences');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That definitely looks like a flare on the left and definitely doesn't on the right!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 1.2 Creating & Training a Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Step 1. Specifiy a directory where you'd like your models to be saved to. " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "OUT_DIR = '/Users/arcticfox/Desktop/results/'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Step 2. Initialize the class! Call $\\texttt{stella.ConvNN()}$ and pass in your directory and the $\\texttt{stella.DataSet}$ object. If you're feeling adventerous, this is also the step where you can pass in a customized CNN architecture by passing in $\\textit{layers}$, and what $\\textit{optimizer}$, $\\textit{metrics}$, and $\\textit{loss}$ function you want to use. The default for each of these variables are described in the associated paper. " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "cnn = stella.ConvNN(output_dir=OUT_DIR,\n", + " ds=ds)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To train your model, simply call $\\texttt{cnn.train_models()}$. By default, this will train a single model over 350 epochs and will pass in a batch size = 64 (which means the CNN will see 64 light curves at a time while training) and use an initial random seed = 2. It's important to keep track of your random seeds so you can reproduce models later, if wanted. Calling this function will also predict on the validation set to give you an idea of how well your CNN is doing. \n\nHowever, if you pass in a list of seeds, then this function will train len(seeds) many models over the same number of epochs. This is useful for $\\textit{ensembling}$, or running a bunch of models and averaging the predicted values over them. \n\nThe models you create will automatically be saved to your output directory in the following file format: 'ensemble_s{0:04d}_i{1:04d}_b{2}.keras'.format(seed, epochs, frac_balance)\n\nFor this tutorial, we will train the CNN for 50 epochs, however we generally recommend training for $\\textbf{at least 300 epochs}$ or until signs of overfitting are seen in the metrics. More information on that below." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "conv1d (Conv1D) (None, 200, 16) 128 \n", + "_________________________________________________________________\n", + "max_pooling1d (MaxPooling1D) (None, 100, 16) 0 \n", + "_________________________________________________________________\n", + "dropout (Dropout) (None, 100, 16) 0 \n", + "_________________________________________________________________\n", + "conv1d_1 (Conv1D) (None, 100, 64) 3136 \n", + "_________________________________________________________________\n", + "max_pooling1d_1 (MaxPooling1 (None, 50, 64) 0 \n", + "_________________________________________________________________\n", + "dropout_1 (Dropout) (None, 50, 64) 0 \n", + "_________________________________________________________________\n", + "flatten (Flatten) (None, 3200) 0 \n", + "_________________________________________________________________\n", + "dense (Dense) (None, 32) 102432 \n", + "_________________________________________________________________\n", + "dropout_2 (Dropout) (None, 32) 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 1) 33 \n", + "=================================================================\n", + "Total params: 105,729\n", + "Trainable params: 105,729\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "Train on 18458 samples, validate on 2307 samples\n", + "Epoch 1/200\n", + "18458/18458 [==============================] - 3s 174us/sample - loss: 0.5494 - accuracy: 0.7645 - precision: 0.2500 - recall: 2.3020e-04 - val_loss: 0.5289 - val_accuracy: 0.7707 - val_precision: 0.0000e+00 - val_recall: 0.0000e+00\n", + "Epoch 2/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.5324 - accuracy: 0.7647 - precision: 0.0000e+00 - recall: 0.0000e+00 - val_loss: 0.4919 - val_accuracy: 0.7707 - val_precision: 0.0000e+00 - val_recall: 0.0000e+00\n", + "Epoch 3/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.4737 - accuracy: 0.7863 - precision: 0.9761 - recall: 0.0942 - val_loss: 0.3863 - val_accuracy: 0.8466 - val_precision: 0.9944 - val_recall: 0.3327\n", + "Epoch 4/200\n", + "18458/18458 [==============================] - 3s 139us/sample - loss: 0.3604 - accuracy: 0.8620 - precision: 0.9653 - recall: 0.4291 - val_loss: 0.3166 - val_accuracy: 0.8643 - val_precision: 0.9865 - val_recall: 0.4140\n", + "Epoch 5/200\n", + "18458/18458 [==============================] - 3s 154us/sample - loss: 0.3120 - accuracy: 0.8820 - precision: 0.9577 - recall: 0.5216 - val_loss: 0.2419 - val_accuracy: 0.9016 - val_precision: 0.9809 - val_recall: 0.5822\n", + "Epoch 6/200\n", + "18458/18458 [==============================] - 3s 137us/sample - loss: 0.2938 - accuracy: 0.8948 - precision: 0.9475 - recall: 0.5854 - val_loss: 0.2647 - val_accuracy: 0.8882 - val_precision: 0.9892 - val_recall: 0.5180\n", + "Epoch 7/200\n", + "18458/18458 [==============================] - 3s 143us/sample - loss: 0.2628 - accuracy: 0.9055 - precision: 0.9514 - recall: 0.6308 - val_loss: 0.2178 - val_accuracy: 0.9137 - val_precision: 0.9797 - val_recall: 0.6371\n", + "Epoch 8/200\n", + "18458/18458 [==============================] - 2s 134us/sample - loss: 0.2715 - accuracy: 0.9031 - precision: 0.9422 - recall: 0.6268 - val_loss: 0.2429 - val_accuracy: 0.9068 - val_precision: 0.9816 - val_recall: 0.6049\n", + "Epoch 9/200\n", + "18458/18458 [==============================] - 3s 147us/sample - loss: 0.2567 - accuracy: 0.9083 - precision: 0.9311 - recall: 0.6593 - val_loss: 0.2139 - val_accuracy: 0.9272 - val_precision: 0.9640 - val_recall: 0.7089\n", + "Epoch 10/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.2447 - accuracy: 0.9140 - precision: 0.9230 - recall: 0.6924 - val_loss: 0.2234 - val_accuracy: 0.9272 - val_precision: 0.9593 - val_recall: 0.7127\n", + "Epoch 11/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.2286 - accuracy: 0.9192 - precision: 0.9242 - recall: 0.7155 - val_loss: 0.1910 - val_accuracy: 0.9332 - val_precision: 0.9518 - val_recall: 0.7467\n", + "Epoch 12/200\n", + "18458/18458 [==============================] - 2s 127us/sample - loss: 0.2241 - accuracy: 0.9227 - precision: 0.9244 - recall: 0.7316 - val_loss: 0.1881 - val_accuracy: 0.9276 - val_precision: 0.9525 - val_recall: 0.7202\n", + "Epoch 13/200\n", + "18458/18458 [==============================] - 2s 132us/sample - loss: 0.2025 - accuracy: 0.9306 - precision: 0.9327 - recall: 0.7599 - val_loss: 0.1686 - val_accuracy: 0.9371 - val_precision: 0.9444 - val_recall: 0.7713\n", + "Epoch 14/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.2141 - accuracy: 0.9288 - precision: 0.9314 - recall: 0.7530 - val_loss: 0.1662 - val_accuracy: 0.9371 - val_precision: 0.9528 - val_recall: 0.7637\n", + "Epoch 15/200\n", + "18458/18458 [==============================] - 3s 142us/sample - loss: 0.2016 - accuracy: 0.9320 - precision: 0.9282 - recall: 0.7705 - val_loss: 0.2023 - val_accuracy: 0.9224 - val_precision: 0.9730 - val_recall: 0.6805\n", + "Epoch 16/200\n", + "18458/18458 [==============================] - 3s 138us/sample - loss: 0.2043 - accuracy: 0.9303 - precision: 0.9245 - recall: 0.7666 - val_loss: 0.1942 - val_accuracy: 0.9306 - val_precision: 0.9792 - val_recall: 0.7127\n", + "Epoch 17/200\n", + "18458/18458 [==============================] - 2s 132us/sample - loss: 0.1916 - accuracy: 0.9362 - precision: 0.9366 - recall: 0.7820 - val_loss: 0.1506 - val_accuracy: 0.9458 - val_precision: 0.9633 - val_recall: 0.7940\n", + "Epoch 18/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.1894 - accuracy: 0.9370 - precision: 0.9364 - recall: 0.7857 - val_loss: 0.1658 - val_accuracy: 0.9363 - val_precision: 0.9848 - val_recall: 0.7335\n", + "Epoch 19/200\n", + "18458/18458 [==============================] - 3s 144us/sample - loss: 0.1748 - accuracy: 0.9426 - precision: 0.9460 - recall: 0.8020 - val_loss: 0.1541 - val_accuracy: 0.9450 - val_precision: 0.9855 - val_recall: 0.7713\n", + "Epoch 20/200\n", + "18458/18458 [==============================] - 3s 143us/sample - loss: 0.1772 - accuracy: 0.9430 - precision: 0.9487 - recall: 0.8011 - val_loss: 0.1432 - val_accuracy: 0.9484 - val_precision: 0.9724 - val_recall: 0.7977\n", + "Epoch 21/200\n", + "18458/18458 [==============================] - 2s 134us/sample - loss: 0.1881 - accuracy: 0.9385 - precision: 0.9378 - recall: 0.7912 - val_loss: 0.1620 - val_accuracy: 0.9402 - val_precision: 0.9780 - val_recall: 0.7561\n", + "Epoch 22/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.1757 - accuracy: 0.9428 - precision: 0.9489 - recall: 0.8002 - val_loss: 0.1311 - val_accuracy: 0.9567 - val_precision: 0.9673 - val_recall: 0.8393\n", + "Epoch 23/200\n", + "18458/18458 [==============================] - 3s 142us/sample - loss: 0.1633 - accuracy: 0.9491 - precision: 0.9568 - recall: 0.8207 - val_loss: 0.1282 - val_accuracy: 0.9575 - val_precision: 0.9615 - val_recall: 0.8488\n", + "Epoch 24/200\n", + "18458/18458 [==============================] - 2s 129us/sample - loss: 0.1653 - accuracy: 0.9467 - precision: 0.9546 - recall: 0.8124 - val_loss: 0.1277 - val_accuracy: 0.9645 - val_precision: 0.9786 - val_recall: 0.8639\n", + "Epoch 25/200\n", + "18458/18458 [==============================] - 3s 138us/sample - loss: 0.1575 - accuracy: 0.9516 - precision: 0.9600 - recall: 0.8290 - val_loss: 0.1345 - val_accuracy: 0.9714 - val_precision: 0.9715 - val_recall: 0.9017\n", + "Epoch 26/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.1517 - accuracy: 0.9518 - precision: 0.9569 - recall: 0.8326 - val_loss: 0.1194 - val_accuracy: 0.9718 - val_precision: 0.9696 - val_recall: 0.9055\n", + "Epoch 27/200\n", + "18458/18458 [==============================] - 2s 134us/sample - loss: 0.1546 - accuracy: 0.9519 - precision: 0.9567 - recall: 0.8336 - val_loss: 0.1546 - val_accuracy: 0.9714 - val_precision: 0.9530 - val_recall: 0.9206\n", + "Epoch 28/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.1399 - accuracy: 0.9561 - precision: 0.9614 - recall: 0.8476 - val_loss: 0.1711 - val_accuracy: 0.9710 - val_precision: 0.9262 - val_recall: 0.9490\n", + "Epoch 29/200\n", + "18458/18458 [==============================] - 2s 132us/sample - loss: 0.1476 - accuracy: 0.9546 - precision: 0.9599 - recall: 0.8423 - val_loss: 0.1175 - val_accuracy: 0.9632 - val_precision: 0.9723 - val_recall: 0.8639\n", + "Epoch 30/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.1420 - accuracy: 0.9562 - precision: 0.9585 - recall: 0.8506 - val_loss: 0.1119 - val_accuracy: 0.9697 - val_precision: 0.9713 - val_recall: 0.8941\n", + "Epoch 31/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.1488 - accuracy: 0.9539 - precision: 0.9561 - recall: 0.8430 - val_loss: 0.1121 - val_accuracy: 0.9736 - val_precision: 0.9680 - val_recall: 0.9149\n", + "Epoch 32/200\n", + "18458/18458 [==============================] - 2s 134us/sample - loss: 0.1413 - accuracy: 0.9567 - precision: 0.9624 - recall: 0.8492 - val_loss: 0.1030 - val_accuracy: 0.9701 - val_precision: 0.9733 - val_recall: 0.8941\n", + "Epoch 33/200\n", + "18458/18458 [==============================] - 2s 134us/sample - loss: 0.1398 - accuracy: 0.9547 - precision: 0.9580 - recall: 0.8444 - val_loss: 0.1127 - val_accuracy: 0.9775 - val_precision: 0.9649 - val_recall: 0.9357\n", + "Epoch 34/200\n", + "18458/18458 [==============================] - 3s 150us/sample - loss: 0.1326 - accuracy: 0.9582 - precision: 0.9625 - recall: 0.8559 - val_loss: 0.1092 - val_accuracy: 0.9775 - val_precision: 0.9704 - val_recall: 0.9301\n", + "Epoch 35/200\n", + "18458/18458 [==============================] - 3s 186us/sample - loss: 0.1385 - accuracy: 0.9577 - precision: 0.9643 - recall: 0.8517 - val_loss: 0.1370 - val_accuracy: 0.9740 - val_precision: 0.9383 - val_recall: 0.9490\n", + "Epoch 36/200\n", + "18458/18458 [==============================] - 4s 207us/sample - loss: 0.1301 - accuracy: 0.9604 - precision: 0.9672 - recall: 0.8610 - val_loss: 0.1323 - val_accuracy: 0.9567 - val_precision: 0.9633 - val_recall: 0.8431\n", + "Epoch 37/200\n", + "18458/18458 [==============================] - 4s 192us/sample - loss: 0.1275 - accuracy: 0.9605 - precision: 0.9626 - recall: 0.8658 - val_loss: 0.1484 - val_accuracy: 0.9749 - val_precision: 0.9305 - val_recall: 0.9622\n", + "Epoch 38/200\n", + "18458/18458 [==============================] - 3s 168us/sample - loss: 0.1423 - accuracy: 0.9550 - precision: 0.9549 - recall: 0.8490 - val_loss: 0.1096 - val_accuracy: 0.9684 - val_precision: 0.9653 - val_recall: 0.8941\n", + "Epoch 39/200\n", + "18458/18458 [==============================] - 3s 146us/sample - loss: 0.1412 - accuracy: 0.9543 - precision: 0.9548 - recall: 0.8460 - val_loss: 0.1397 - val_accuracy: 0.9701 - val_precision: 0.9212 - val_recall: 0.9509\n", + "Epoch 40/200\n", + "18458/18458 [==============================] - 3s 138us/sample - loss: 0.1285 - accuracy: 0.9598 - precision: 0.9649 - recall: 0.8605 - val_loss: 0.1038 - val_accuracy: 0.9679 - val_precision: 0.9577 - val_recall: 0.8998\n", + "Epoch 41/200\n", + "18458/18458 [==============================] - 3s 144us/sample - loss: 0.1324 - accuracy: 0.9584 - precision: 0.9625 - recall: 0.8568 - val_loss: 0.1238 - val_accuracy: 0.9757 - val_precision: 0.9355 - val_recall: 0.9603\n", + "Epoch 42/200\n", + "18458/18458 [==============================] - 3s 142us/sample - loss: 0.1273 - accuracy: 0.9613 - precision: 0.9635 - recall: 0.8686 - val_loss: 0.2219 - val_accuracy: 0.9376 - val_precision: 0.7966 - val_recall: 0.9773\n", + "Epoch 43/200\n", + "18458/18458 [==============================] - 3s 145us/sample - loss: 0.1220 - accuracy: 0.9625 - precision: 0.9670 - recall: 0.8702 - val_loss: 0.0966 - val_accuracy: 0.9701 - val_precision: 0.9832 - val_recall: 0.8847\n", + "Epoch 44/200\n", + "18458/18458 [==============================] - 3s 152us/sample - loss: 0.1265 - accuracy: 0.9610 - precision: 0.9658 - recall: 0.8651 - val_loss: 0.0997 - val_accuracy: 0.9697 - val_precision: 0.9752 - val_recall: 0.8904\n", + "Epoch 45/200\n", + "18458/18458 [==============================] - 3s 143us/sample - loss: 0.1268 - accuracy: 0.9615 - precision: 0.9633 - recall: 0.8695 - val_loss: 0.0941 - val_accuracy: 0.9710 - val_precision: 0.9676 - val_recall: 0.9036\n", + "Epoch 46/200\n", + "18458/18458 [==============================] - 3s 149us/sample - loss: 0.1285 - accuracy: 0.9601 - precision: 0.9635 - recall: 0.8633 - val_loss: 0.1479 - val_accuracy: 0.9684 - val_precision: 0.9028 - val_recall: 0.9660\n", + "Epoch 47/200\n", + "18458/18458 [==============================] - 3s 143us/sample - loss: 0.1328 - accuracy: 0.9585 - precision: 0.9571 - recall: 0.8623 - val_loss: 0.1346 - val_accuracy: 0.9658 - val_precision: 0.9151 - val_recall: 0.9376\n", + "Epoch 48/200\n", + "18458/18458 [==============================] - 3s 137us/sample - loss: 0.1177 - accuracy: 0.9627 - precision: 0.9668 - recall: 0.8713 - val_loss: 0.1043 - val_accuracy: 0.9770 - val_precision: 0.9440 - val_recall: 0.9565\n", + "Epoch 49/200\n", + "18458/18458 [==============================] - 3s 144us/sample - loss: 0.1247 - accuracy: 0.9613 - precision: 0.9649 - recall: 0.8669 - val_loss: 0.0888 - val_accuracy: 0.9705 - val_precision: 0.9792 - val_recall: 0.8904\n", + "Epoch 50/200\n", + "18458/18458 [==============================] - 3s 159us/sample - loss: 0.1171 - accuracy: 0.9642 - precision: 0.9668 - recall: 0.8780 - val_loss: 0.0991 - val_accuracy: 0.9701 - val_precision: 0.9812 - val_recall: 0.8866\n", + "Epoch 51/200\n", + "18458/18458 [==============================] - 3s 169us/sample - loss: 0.1190 - accuracy: 0.9638 - precision: 0.9674 - recall: 0.8755 - val_loss: 0.1182 - val_accuracy: 0.9723 - val_precision: 0.9204 - val_recall: 0.9622\n", + "Epoch 52/200\n", + "18458/18458 [==============================] - 3s 161us/sample - loss: 0.1179 - accuracy: 0.9628 - precision: 0.9635 - recall: 0.8752 - val_loss: 0.1217 - val_accuracy: 0.9627 - val_precision: 0.9743 - val_recall: 0.8601\n", + "Epoch 53/200\n", + "18458/18458 [==============================] - 3s 150us/sample - loss: 0.1166 - accuracy: 0.9632 - precision: 0.9671 - recall: 0.8734 - val_loss: 0.1692 - val_accuracy: 0.9649 - val_precision: 0.8836 - val_recall: 0.9754\n", + "Epoch 54/200\n", + "18458/18458 [==============================] - 3s 138us/sample - loss: 0.1164 - accuracy: 0.9627 - precision: 0.9661 - recall: 0.8720 - val_loss: 0.0974 - val_accuracy: 0.9783 - val_precision: 0.9460 - val_recall: 0.9603\n", + "Epoch 55/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.1215 - accuracy: 0.9627 - precision: 0.9659 - recall: 0.8725 - val_loss: 0.1093 - val_accuracy: 0.9766 - val_precision: 0.9406 - val_recall: 0.9584\n", + "Epoch 56/200\n", + "18458/18458 [==============================] - 3s 138us/sample - loss: 0.1217 - accuracy: 0.9619 - precision: 0.9636 - recall: 0.8709 - val_loss: 0.0962 - val_accuracy: 0.9783 - val_precision: 0.9460 - val_recall: 0.9603\n", + "Epoch 57/200\n", + "18458/18458 [==============================] - 3s 144us/sample - loss: 0.1147 - accuracy: 0.9635 - precision: 0.9672 - recall: 0.8748 - val_loss: 0.1161 - val_accuracy: 0.9744 - val_precision: 0.9288 - val_recall: 0.9622\n", + "Epoch 58/200\n", + "18458/18458 [==============================] - 3s 141us/sample - loss: 0.1266 - accuracy: 0.9596 - precision: 0.9610 - recall: 0.8633 - val_loss: 0.1003 - val_accuracy: 0.9697 - val_precision: 0.9674 - val_recall: 0.8979\n", + "Epoch 59/200\n", + "18458/18458 [==============================] - 3s 145us/sample - loss: 0.1082 - accuracy: 0.9647 - precision: 0.9641 - recall: 0.8831 - val_loss: 0.0879 - val_accuracy: 0.9710 - val_precision: 0.9833 - val_recall: 0.8885\n", + "Epoch 60/200\n", + "18458/18458 [==============================] - 3s 142us/sample - loss: 0.1127 - accuracy: 0.9633 - precision: 0.9636 - recall: 0.8773 - val_loss: 0.0904 - val_accuracy: 0.9727 - val_precision: 0.9854 - val_recall: 0.8941\n", + "Epoch 61/200\n", + "18458/18458 [==============================] - 3s 143us/sample - loss: 0.1044 - accuracy: 0.9679 - precision: 0.9688 - recall: 0.8923 - val_loss: 0.1206 - val_accuracy: 0.9688 - val_precision: 0.9044 - val_recall: 0.9660\n", + "Epoch 62/200\n", + "18458/18458 [==============================] - 3s 143us/sample - loss: 0.1095 - accuracy: 0.9641 - precision: 0.9619 - recall: 0.8824 - val_loss: 0.1610 - val_accuracy: 0.9545 - val_precision: 0.8522 - val_recall: 0.9698\n", + "Epoch 63/200\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "18458/18458 [==============================] - 3s 140us/sample - loss: 0.0996 - accuracy: 0.9681 - precision: 0.9686 - recall: 0.8936 - val_loss: 0.0970 - val_accuracy: 0.9775 - val_precision: 0.9425 - val_recall: 0.9603\n", + "Epoch 64/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.1073 - accuracy: 0.9670 - precision: 0.9670 - recall: 0.8900 - val_loss: 0.0922 - val_accuracy: 0.9744 - val_precision: 0.9368 - val_recall: 0.9527\n", + "Epoch 65/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.1280 - accuracy: 0.9597 - precision: 0.9658 - recall: 0.8591 - val_loss: 0.1154 - val_accuracy: 0.9688 - val_precision: 0.9117 - val_recall: 0.9565\n", + "Epoch 66/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.1054 - accuracy: 0.9672 - precision: 0.9722 - recall: 0.8860 - val_loss: 0.0749 - val_accuracy: 0.9766 - val_precision: 0.9612 - val_recall: 0.9357\n", + "Epoch 67/200\n", + "18458/18458 [==============================] - 2s 132us/sample - loss: 0.1024 - accuracy: 0.9691 - precision: 0.9682 - recall: 0.8983 - val_loss: 0.0882 - val_accuracy: 0.9723 - val_precision: 0.9412 - val_recall: 0.9376\n", + "Epoch 68/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.1017 - accuracy: 0.9684 - precision: 0.9709 - recall: 0.8923 - val_loss: 0.0765 - val_accuracy: 0.9792 - val_precision: 0.9529 - val_recall: 0.9565\n", + "Epoch 69/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.1056 - accuracy: 0.9665 - precision: 0.9662 - recall: 0.8886 - val_loss: 0.1364 - val_accuracy: 0.9645 - val_precision: 0.8847 - val_recall: 0.9716\n", + "Epoch 70/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.1099 - accuracy: 0.9668 - precision: 0.9670 - recall: 0.8893 - val_loss: 0.1352 - val_accuracy: 0.9619 - val_precision: 0.8769 - val_recall: 0.9698\n", + "Epoch 71/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.1013 - accuracy: 0.9669 - precision: 0.9670 - recall: 0.8897 - val_loss: 0.0828 - val_accuracy: 0.9796 - val_precision: 0.9513 - val_recall: 0.9603\n", + "Epoch 72/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.1045 - accuracy: 0.9680 - precision: 0.9695 - recall: 0.8923 - val_loss: 0.0694 - val_accuracy: 0.9766 - val_precision: 0.9837 - val_recall: 0.9130\n", + "Epoch 73/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.1014 - accuracy: 0.9668 - precision: 0.9674 - recall: 0.8888 - val_loss: 0.1153 - val_accuracy: 0.9671 - val_precision: 0.8953 - val_recall: 0.9698\n", + "Epoch 74/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.1091 - accuracy: 0.9641 - precision: 0.9663 - recall: 0.8782 - val_loss: 0.0874 - val_accuracy: 0.9753 - val_precision: 0.9664 - val_recall: 0.9244\n", + "Epoch 75/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.0947 - accuracy: 0.9706 - precision: 0.9698 - recall: 0.9031 - val_loss: 0.1204 - val_accuracy: 0.9593 - val_precision: 0.9801 - val_recall: 0.8393\n", + "Epoch 76/200\n", + "18458/18458 [==============================] - 2s 134us/sample - loss: 0.1010 - accuracy: 0.9691 - precision: 0.9720 - recall: 0.8946 - val_loss: 0.0929 - val_accuracy: 0.9783 - val_precision: 0.9362 - val_recall: 0.9716\n", + "Epoch 77/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.0931 - accuracy: 0.9709 - precision: 0.9685 - recall: 0.9058 - val_loss: 0.0737 - val_accuracy: 0.9770 - val_precision: 0.9837 - val_recall: 0.9149\n", + "Epoch 78/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.0983 - accuracy: 0.9686 - precision: 0.9698 - recall: 0.8946 - val_loss: 0.0979 - val_accuracy: 0.9757 - val_precision: 0.9261 - val_recall: 0.9716\n", + "Epoch 79/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.0980 - accuracy: 0.9687 - precision: 0.9712 - recall: 0.8936 - val_loss: 0.0732 - val_accuracy: 0.9753 - val_precision: 0.9609 - val_recall: 0.9301\n", + "Epoch 80/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.0974 - accuracy: 0.9698 - precision: 0.9704 - recall: 0.8989 - val_loss: 0.3404 - val_accuracy: 0.8331 - val_precision: 0.5793 - val_recall: 0.9943\n", + "Epoch 81/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0957 - accuracy: 0.9685 - precision: 0.9649 - recall: 0.8989 - val_loss: 0.0779 - val_accuracy: 0.9801 - val_precision: 0.9514 - val_recall: 0.9622\n", + "Epoch 82/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0977 - accuracy: 0.9691 - precision: 0.9689 - recall: 0.8976 - val_loss: 0.1189 - val_accuracy: 0.9636 - val_precision: 0.8843 - val_recall: 0.9679\n", + "Epoch 83/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.1032 - accuracy: 0.9686 - precision: 0.9724 - recall: 0.8918 - val_loss: 0.1481 - val_accuracy: 0.9523 - val_precision: 0.8463 - val_recall: 0.9679\n", + "Epoch 84/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0898 - accuracy: 0.9713 - precision: 0.9706 - recall: 0.9056 - val_loss: 0.1526 - val_accuracy: 0.9549 - val_precision: 0.8489 - val_recall: 0.9773\n", + "Epoch 85/200\n", + "18458/18458 [==============================] - 3s 135us/sample - loss: 0.0930 - accuracy: 0.9711 - precision: 0.9694 - recall: 0.9056 - val_loss: 0.0901 - val_accuracy: 0.9783 - val_precision: 0.9378 - val_recall: 0.9698\n", + "Epoch 86/200\n", + "18458/18458 [==============================] - 3s 138us/sample - loss: 0.0908 - accuracy: 0.9713 - precision: 0.9695 - recall: 0.9065 - val_loss: 0.0664 - val_accuracy: 0.9792 - val_precision: 0.9598 - val_recall: 0.9490\n", + "Epoch 87/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.0961 - accuracy: 0.9710 - precision: 0.9708 - recall: 0.9038 - val_loss: 0.1742 - val_accuracy: 0.9480 - val_precision: 0.8231 - val_recall: 0.9849\n", + "Epoch 88/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0930 - accuracy: 0.9714 - precision: 0.9723 - recall: 0.9045 - val_loss: 0.0733 - val_accuracy: 0.9766 - val_precision: 0.9507 - val_recall: 0.9471\n", + "Epoch 89/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0891 - accuracy: 0.9719 - precision: 0.9705 - recall: 0.9084 - val_loss: 0.0863 - val_accuracy: 0.9710 - val_precision: 0.9894 - val_recall: 0.8828\n", + "Epoch 90/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0916 - accuracy: 0.9716 - precision: 0.9714 - recall: 0.9061 - val_loss: 0.0992 - val_accuracy: 0.9766 - val_precision: 0.9295 - val_recall: 0.9716\n", + "Epoch 91/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0935 - accuracy: 0.9716 - precision: 0.9704 - recall: 0.9068 - val_loss: 0.0771 - val_accuracy: 0.9792 - val_precision: 0.9512 - val_recall: 0.9584\n", + "Epoch 92/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0949 - accuracy: 0.9701 - precision: 0.9705 - recall: 0.9003 - val_loss: 0.1643 - val_accuracy: 0.9480 - val_precision: 0.8251 - val_recall: 0.9811\n", + "Epoch 93/200\n", + "18458/18458 [==============================] - 3s 148us/sample - loss: 0.0939 - accuracy: 0.9699 - precision: 0.9707 - recall: 0.8994 - val_loss: 0.1503 - val_accuracy: 0.9536 - val_precision: 0.8436 - val_recall: 0.9792\n", + "Epoch 94/200\n", + "18458/18458 [==============================] - 3s 174us/sample - loss: 0.0853 - accuracy: 0.9726 - precision: 0.9722 - recall: 0.9095 - val_loss: 0.0682 - val_accuracy: 0.9809 - val_precision: 0.9550 - val_recall: 0.9622\n", + "Epoch 95/200\n", + "18458/18458 [==============================] - 3s 172us/sample - loss: 0.0918 - accuracy: 0.9735 - precision: 0.9742 - recall: 0.9114 - val_loss: 0.1143 - val_accuracy: 0.9675 - val_precision: 0.8914 - val_recall: 0.9773\n", + "Epoch 96/200\n", + "18458/18458 [==============================] - 3s 166us/sample - loss: 0.0991 - accuracy: 0.9674 - precision: 0.9636 - recall: 0.8953 - val_loss: 0.1964 - val_accuracy: 0.9380 - val_precision: 0.7915 - val_recall: 0.9905\n", + "Epoch 97/200\n", + "18458/18458 [==============================] - 3s 160us/sample - loss: 0.0984 - accuracy: 0.9678 - precision: 0.9659 - recall: 0.8946 - val_loss: 0.0652 - val_accuracy: 0.9814 - val_precision: 0.9602 - val_recall: 0.9584\n", + "Epoch 98/200\n", + "18458/18458 [==============================] - 3s 139us/sample - loss: 0.0891 - accuracy: 0.9730 - precision: 0.9722 - recall: 0.9111 - val_loss: 0.0734 - val_accuracy: 0.9809 - val_precision: 0.9482 - val_recall: 0.9698\n", + "Epoch 99/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0890 - accuracy: 0.9712 - precision: 0.9681 - recall: 0.9077 - val_loss: 0.1848 - val_accuracy: 0.9410 - val_precision: 0.8028 - val_recall: 0.9849\n", + "Epoch 100/200\n", + "18458/18458 [==============================] - 2s 134us/sample - loss: 0.0870 - accuracy: 0.9724 - precision: 0.9717 - recall: 0.9091 - val_loss: 0.1258 - val_accuracy: 0.9619 - val_precision: 0.8718 - val_recall: 0.9773\n", + "Epoch 101/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0971 - accuracy: 0.9697 - precision: 0.9699 - recall: 0.8989 - val_loss: 0.0624 - val_accuracy: 0.9788 - val_precision: 0.9800 - val_recall: 0.9263\n", + "Epoch 102/200\n", + "18458/18458 [==============================] - 2s 132us/sample - loss: 0.0995 - accuracy: 0.9691 - precision: 0.9696 - recall: 0.8966 - val_loss: 0.0798 - val_accuracy: 0.9736 - val_precision: 0.9916 - val_recall: 0.8922\n", + "Epoch 103/200\n", + "18458/18458 [==============================] - 3s 143us/sample - loss: 0.0925 - accuracy: 0.9718 - precision: 0.9733 - recall: 0.9049 - val_loss: 0.0652 - val_accuracy: 0.9818 - val_precision: 0.9586 - val_recall: 0.9622\n", + "Epoch 104/200\n", + "18458/18458 [==============================] - 3s 141us/sample - loss: 0.0911 - accuracy: 0.9705 - precision: 0.9701 - recall: 0.9026 - val_loss: 0.1040 - val_accuracy: 0.9697 - val_precision: 0.8991 - val_recall: 0.9773\n", + "Epoch 105/200\n", + "18458/18458 [==============================] - 3s 141us/sample - loss: 0.0922 - accuracy: 0.9706 - precision: 0.9694 - recall: 0.9035 - val_loss: 0.1581 - val_accuracy: 0.9519 - val_precision: 0.8382 - val_recall: 0.9792\n", + "Epoch 106/200\n", + "18458/18458 [==============================] - 3s 139us/sample - loss: 0.1069 - accuracy: 0.9667 - precision: 0.9635 - recall: 0.8925 - val_loss: 0.1421 - val_accuracy: 0.9567 - val_precision: 0.8557 - val_recall: 0.9754\n", + "Epoch 107/200\n", + "18458/18458 [==============================] - 3s 141us/sample - loss: 0.0930 - accuracy: 0.9710 - precision: 0.9720 - recall: 0.9029 - val_loss: 0.1410 - val_accuracy: 0.9562 - val_precision: 0.8543 - val_recall: 0.9754\n", + "Epoch 108/200\n", + "18458/18458 [==============================] - 3s 139us/sample - loss: 0.0886 - accuracy: 0.9722 - precision: 0.9735 - recall: 0.9065 - val_loss: 0.1257 - val_accuracy: 0.9627 - val_precision: 0.8761 - val_recall: 0.9754\n", + "Epoch 109/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.0888 - accuracy: 0.9717 - precision: 0.9712 - recall: 0.9068 - val_loss: 0.0702 - val_accuracy: 0.9818 - val_precision: 0.9534 - val_recall: 0.9679\n", + "Epoch 110/200\n", + "18458/18458 [==============================] - 3s 138us/sample - loss: 0.0936 - accuracy: 0.9711 - precision: 0.9722 - recall: 0.9029 - val_loss: 0.0883 - val_accuracy: 0.9749 - val_precision: 0.9213 - val_recall: 0.9735\n", + "Epoch 111/200\n", + "18458/18458 [==============================] - 3s 138us/sample - loss: 0.0896 - accuracy: 0.9719 - precision: 0.9712 - recall: 0.9077 - val_loss: 0.0853 - val_accuracy: 0.9775 - val_precision: 0.9328 - val_recall: 0.9716\n", + "Epoch 112/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0909 - accuracy: 0.9724 - precision: 0.9710 - recall: 0.9098 - val_loss: 0.1586 - val_accuracy: 0.9523 - val_precision: 0.8429 - val_recall: 0.9735\n", + "Epoch 113/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0875 - accuracy: 0.9717 - precision: 0.9719 - recall: 0.9061 - val_loss: 0.0689 - val_accuracy: 0.9809 - val_precision: 0.9602 - val_recall: 0.9565\n", + "Epoch 114/200\n", + "18458/18458 [==============================] - 3s 153us/sample - loss: 0.0836 - accuracy: 0.9737 - precision: 0.9758 - recall: 0.9107 - val_loss: 0.0657 - val_accuracy: 0.9818 - val_precision: 0.9518 - val_recall: 0.9698\n", + "Epoch 115/200\n", + "18458/18458 [==============================] - 3s 142us/sample - loss: 0.0921 - accuracy: 0.9711 - precision: 0.9708 - recall: 0.9042 - val_loss: 0.0702 - val_accuracy: 0.9805 - val_precision: 0.9498 - val_recall: 0.9660\n", + "Epoch 116/200\n", + "18458/18458 [==============================] - 3s 140us/sample - loss: 0.0974 - accuracy: 0.9690 - precision: 0.9671 - recall: 0.8987 - val_loss: 0.1202 - val_accuracy: 0.9649 - val_precision: 0.8875 - val_recall: 0.9698\n", + "Epoch 117/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.0850 - accuracy: 0.9722 - precision: 0.9717 - recall: 0.9084 - val_loss: 0.1045 - val_accuracy: 0.9714 - val_precision: 0.9069 - val_recall: 0.9754\n", + "Epoch 118/200\n", + "18458/18458 [==============================] - 3s 162us/sample - loss: 0.0857 - accuracy: 0.9741 - precision: 0.9733 - recall: 0.9151 - val_loss: 0.0758 - val_accuracy: 0.9809 - val_precision: 0.9499 - val_recall: 0.9679\n", + "Epoch 119/200\n", + "18458/18458 [==============================] - 3s 156us/sample - loss: 0.0863 - accuracy: 0.9729 - precision: 0.9729 - recall: 0.9100 - val_loss: 0.2024 - val_accuracy: 0.9315 - val_precision: 0.7732 - val_recall: 0.9924\n", + "Epoch 120/200\n", + "18458/18458 [==============================] - 3s 155us/sample - loss: 0.1031 - accuracy: 0.9690 - precision: 0.9694 - recall: 0.8966 - val_loss: 0.0815 - val_accuracy: 0.9705 - val_precision: 0.9458 - val_recall: 0.9244\n", + "Epoch 121/200\n", + "18458/18458 [==============================] - 3s 155us/sample - loss: 0.0880 - accuracy: 0.9724 - precision: 0.9712 - recall: 0.9098 - val_loss: 0.1191 - val_accuracy: 0.9662 - val_precision: 0.9005 - val_recall: 0.9584\n", + "Epoch 122/200\n", + "18458/18458 [==============================] - 3s 145us/sample - loss: 0.0942 - accuracy: 0.9706 - precision: 0.9684 - recall: 0.9045 - val_loss: 0.1026 - val_accuracy: 0.9697 - val_precision: 0.9005 - val_recall: 0.9754\n", + "Epoch 123/200\n", + "18458/18458 [==============================] - 3s 137us/sample - loss: 0.0876 - accuracy: 0.9722 - precision: 0.9735 - recall: 0.9065 - val_loss: 0.0634 - val_accuracy: 0.9814 - val_precision: 0.9620 - val_recall: 0.9565\n", + "Epoch 124/200\n", + "18458/18458 [==============================] - 3s 145us/sample - loss: 0.0854 - accuracy: 0.9725 - precision: 0.9715 - recall: 0.9098 - val_loss: 0.0870 - val_accuracy: 0.9736 - val_precision: 0.9179 - val_recall: 0.9716\n", + "Epoch 125/200\n", + "18458/18458 [==============================] - 3s 147us/sample - loss: 0.0901 - accuracy: 0.9721 - precision: 0.9717 - recall: 0.9079 - val_loss: 0.1402 - val_accuracy: 0.9541 - val_precision: 0.8484 - val_recall: 0.9735\n", + "Epoch 126/200\n", + "18458/18458 [==============================] - 3s 137us/sample - loss: 0.0903 - accuracy: 0.9718 - precision: 0.9712 - recall: 0.9072 - val_loss: 0.1050 - val_accuracy: 0.9666 - val_precision: 0.8979 - val_recall: 0.9641\n", + "Epoch 127/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0899 - accuracy: 0.9718 - precision: 0.9721 - recall: 0.9063 - val_loss: 0.0627 - val_accuracy: 0.9775 - val_precision: 0.9818 - val_recall: 0.9187\n", + "Epoch 128/200\n", + "18458/18458 [==============================] - 3s 148us/sample - loss: 0.0909 - accuracy: 0.9714 - precision: 0.9709 - recall: 0.9056 - val_loss: 0.1331 - val_accuracy: 0.9619 - val_precision: 0.8693 - val_recall: 0.9811\n", + "Epoch 129/200\n", + "18458/18458 [==============================] - 3s 140us/sample - loss: 0.0987 - accuracy: 0.9680 - precision: 0.9681 - recall: 0.8936 - val_loss: 0.1068 - val_accuracy: 0.9666 - val_precision: 0.8897 - val_recall: 0.9754\n", + "Epoch 130/200\n", + "18458/18458 [==============================] - 3s 140us/sample - loss: 0.0808 - accuracy: 0.9746 - precision: 0.9745 - recall: 0.9160 - val_loss: 0.0795 - val_accuracy: 0.9753 - val_precision: 0.9260 - val_recall: 0.9698\n", + "Epoch 131/200\n", + "18458/18458 [==============================] - 3s 140us/sample - loss: 0.0899 - accuracy: 0.9722 - precision: 0.9698 - recall: 0.9100 - val_loss: 0.1077 - val_accuracy: 0.9623 - val_precision: 0.8932 - val_recall: 0.9490\n", + "Epoch 132/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0853 - accuracy: 0.9739 - precision: 0.9731 - recall: 0.9146 - val_loss: 0.1118 - val_accuracy: 0.9627 - val_precision: 0.8799 - val_recall: 0.9698\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 133/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.0965 - accuracy: 0.9697 - precision: 0.9690 - recall: 0.8999 - val_loss: 0.1128 - val_accuracy: 0.9575 - val_precision: 0.8954 - val_recall: 0.9225\n", + "Epoch 134/200\n", + "18458/18458 [==============================] - 2s 130us/sample - loss: 0.0885 - accuracy: 0.9717 - precision: 0.9682 - recall: 0.9098 - val_loss: 0.0859 - val_accuracy: 0.9701 - val_precision: 0.9064 - val_recall: 0.9698\n", + "Epoch 135/200\n", + "18458/18458 [==============================] - 2s 129us/sample - loss: 0.0915 - accuracy: 0.9706 - precision: 0.9682 - recall: 0.9049 - val_loss: 0.0814 - val_accuracy: 0.9749 - val_precision: 0.9274 - val_recall: 0.9660\n", + "Epoch 136/200\n", + "18458/18458 [==============================] - 2s 129us/sample - loss: 0.0927 - accuracy: 0.9712 - precision: 0.9699 - recall: 0.9058 - val_loss: 0.1020 - val_accuracy: 0.9688 - val_precision: 0.8988 - val_recall: 0.9735\n", + "Epoch 137/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.0865 - accuracy: 0.9732 - precision: 0.9725 - recall: 0.9121 - val_loss: 0.0615 - val_accuracy: 0.9822 - val_precision: 0.9552 - val_recall: 0.9679\n", + "Epoch 138/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0812 - accuracy: 0.9752 - precision: 0.9741 - recall: 0.9192 - val_loss: 0.0655 - val_accuracy: 0.9801 - val_precision: 0.9497 - val_recall: 0.9641\n", + "Epoch 139/200\n", + "18458/18458 [==============================] - 3s 137us/sample - loss: 0.0857 - accuracy: 0.9737 - precision: 0.9749 - recall: 0.9116 - val_loss: 0.1483 - val_accuracy: 0.9536 - val_precision: 0.8403 - val_recall: 0.9849\n", + "Epoch 140/200\n", + "18458/18458 [==============================] - 3s 138us/sample - loss: 0.1002 - accuracy: 0.9686 - precision: 0.9682 - recall: 0.8959 - val_loss: 0.1285 - val_accuracy: 0.9610 - val_precision: 0.8702 - val_recall: 0.9754\n", + "Epoch 141/200\n", + "18458/18458 [==============================] - 3s 143us/sample - loss: 0.0845 - accuracy: 0.9732 - precision: 0.9707 - recall: 0.9137 - val_loss: 0.0677 - val_accuracy: 0.9783 - val_precision: 0.9632 - val_recall: 0.9414\n", + "Epoch 142/200\n", + "18458/18458 [==============================] - 3s 137us/sample - loss: 0.0894 - accuracy: 0.9720 - precision: 0.9707 - recall: 0.9084 - val_loss: 0.1276 - val_accuracy: 0.9614 - val_precision: 0.8691 - val_recall: 0.9792\n", + "Epoch 143/200\n", + "18458/18458 [==============================] - 3s 137us/sample - loss: 0.0876 - accuracy: 0.9717 - precision: 0.9675 - recall: 0.9105 - val_loss: 0.1315 - val_accuracy: 0.9575 - val_precision: 0.8598 - val_recall: 0.9735\n", + "Epoch 144/200\n", + "18458/18458 [==============================] - 2s 134us/sample - loss: 0.0983 - accuracy: 0.9679 - precision: 0.9683 - recall: 0.8930 - val_loss: 0.0673 - val_accuracy: 0.9805 - val_precision: 0.9583 - val_recall: 0.9565\n", + "Epoch 145/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.0851 - accuracy: 0.9726 - precision: 0.9692 - recall: 0.9128 - val_loss: 0.0735 - val_accuracy: 0.9762 - val_precision: 0.9309 - val_recall: 0.9679\n", + "Epoch 146/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.0843 - accuracy: 0.9733 - precision: 0.9707 - recall: 0.9144 - val_loss: 0.0745 - val_accuracy: 0.9762 - val_precision: 0.9309 - val_recall: 0.9679\n", + "Epoch 147/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.0854 - accuracy: 0.9731 - precision: 0.9718 - recall: 0.9121 - val_loss: 0.0767 - val_accuracy: 0.9740 - val_precision: 0.9718 - val_recall: 0.9130\n", + "Epoch 148/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.0862 - accuracy: 0.9727 - precision: 0.9694 - recall: 0.9130 - val_loss: 0.0895 - val_accuracy: 0.9705 - val_precision: 0.9094 - val_recall: 0.9679\n", + "Epoch 149/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0892 - accuracy: 0.9712 - precision: 0.9683 - recall: 0.9072 - val_loss: 0.0793 - val_accuracy: 0.9779 - val_precision: 0.9377 - val_recall: 0.9679\n", + "Epoch 150/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.0947 - accuracy: 0.9705 - precision: 0.9696 - recall: 0.9031 - val_loss: 0.1545 - val_accuracy: 0.9536 - val_precision: 0.8425 - val_recall: 0.9811\n", + "Epoch 151/200\n", + "18458/18458 [==============================] - 3s 137us/sample - loss: 0.0906 - accuracy: 0.9716 - precision: 0.9681 - recall: 0.9091 - val_loss: 0.0634 - val_accuracy: 0.9788 - val_precision: 0.9858 - val_recall: 0.9206\n", + "Epoch 152/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.0887 - accuracy: 0.9726 - precision: 0.9720 - recall: 0.9098 - val_loss: 0.1612 - val_accuracy: 0.9502 - val_precision: 0.8339 - val_recall: 0.9773\n", + "Epoch 153/200\n", + "18458/18458 [==============================] - 2s 134us/sample - loss: 0.0977 - accuracy: 0.9687 - precision: 0.9663 - recall: 0.8983 - val_loss: 0.1101 - val_accuracy: 0.9645 - val_precision: 0.8807 - val_recall: 0.9773\n", + "Epoch 154/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.0745 - accuracy: 0.9771 - precision: 0.9750 - recall: 0.9263 - val_loss: 0.1646 - val_accuracy: 0.9571 - val_precision: 0.8525 - val_recall: 0.9830\n", + "Epoch 155/200\n", + "18458/18458 [==============================] - 3s 139us/sample - loss: 0.0822 - accuracy: 0.9737 - precision: 0.9735 - recall: 0.9130 - val_loss: 0.1084 - val_accuracy: 0.9623 - val_precision: 0.8877 - val_recall: 0.9565\n", + "Epoch 156/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0830 - accuracy: 0.9721 - precision: 0.9664 - recall: 0.9132 - val_loss: 0.0739 - val_accuracy: 0.9766 - val_precision: 0.9326 - val_recall: 0.9679\n", + "Epoch 157/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.0809 - accuracy: 0.9742 - precision: 0.9736 - recall: 0.9153 - val_loss: 0.1272 - val_accuracy: 0.9692 - val_precision: 0.8976 - val_recall: 0.9773\n", + "Epoch 158/200\n", + "18458/18458 [==============================] - 2s 134us/sample - loss: 0.0957 - accuracy: 0.9708 - precision: 0.9685 - recall: 0.9054 - val_loss: 0.0702 - val_accuracy: 0.9801 - val_precision: 0.9464 - val_recall: 0.9679\n", + "Epoch 159/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0760 - accuracy: 0.9756 - precision: 0.9739 - recall: 0.9208 - val_loss: 0.1130 - val_accuracy: 0.9736 - val_precision: 0.9224 - val_recall: 0.9660\n", + "Epoch 160/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0873 - accuracy: 0.9726 - precision: 0.9722 - recall: 0.9098 - val_loss: 0.1625 - val_accuracy: 0.9484 - val_precision: 0.8213 - val_recall: 0.9905\n", + "Epoch 161/200\n", + "18458/18458 [==============================] - 2s 130us/sample - loss: 0.0889 - accuracy: 0.9708 - precision: 0.9696 - recall: 0.9042 - val_loss: 0.1490 - val_accuracy: 0.9510 - val_precision: 0.8344 - val_recall: 0.9811\n", + "Epoch 162/200\n", + "18458/18458 [==============================] - 2s 129us/sample - loss: 0.0771 - accuracy: 0.9758 - precision: 0.9735 - recall: 0.9222 - val_loss: 0.0893 - val_accuracy: 0.9740 - val_precision: 0.9180 - val_recall: 0.9735\n", + "Epoch 163/200\n", + "18458/18458 [==============================] - 2s 127us/sample - loss: 0.0778 - accuracy: 0.9752 - precision: 0.9725 - recall: 0.9208 - val_loss: 0.1083 - val_accuracy: 0.9645 - val_precision: 0.8834 - val_recall: 0.9735\n", + "Epoch 164/200\n", + "18458/18458 [==============================] - 2s 128us/sample - loss: 0.0917 - accuracy: 0.9722 - precision: 0.9738 - recall: 0.9061 - val_loss: 0.1728 - val_accuracy: 0.9410 - val_precision: 0.8066 - val_recall: 0.9773\n", + "Epoch 165/200\n", + "18458/18458 [==============================] - 2s 130us/sample - loss: 0.0893 - accuracy: 0.9721 - precision: 0.9689 - recall: 0.9107 - val_loss: 0.0724 - val_accuracy: 0.9805 - val_precision: 0.9465 - val_recall: 0.9698\n", + "Epoch 166/200\n", + "18458/18458 [==============================] - 2s 132us/sample - loss: 0.0803 - accuracy: 0.9741 - precision: 0.9719 - recall: 0.9164 - val_loss: 0.0907 - val_accuracy: 0.9701 - val_precision: 0.9244 - val_recall: 0.9471\n", + "Epoch 167/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0843 - accuracy: 0.9752 - precision: 0.9744 - recall: 0.9187 - val_loss: 0.0675 - val_accuracy: 0.9805 - val_precision: 0.9515 - val_recall: 0.9641\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 168/200\n", + "18458/18458 [==============================] - 2s 134us/sample - loss: 0.0885 - accuracy: 0.9733 - precision: 0.9723 - recall: 0.9128 - val_loss: 0.2243 - val_accuracy: 0.9207 - val_precision: 0.7464 - val_recall: 0.9905\n", + "Epoch 169/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0760 - accuracy: 0.9772 - precision: 0.9778 - recall: 0.9240 - val_loss: 0.1398 - val_accuracy: 0.9545 - val_precision: 0.8464 - val_recall: 0.9792\n", + "Epoch 170/200\n", + "18458/18458 [==============================] - 3s 137us/sample - loss: 0.0936 - accuracy: 0.9717 - precision: 0.9716 - recall: 0.9063 - val_loss: 0.1020 - val_accuracy: 0.9649 - val_precision: 0.9870 - val_recall: 0.8582\n", + "Epoch 171/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0839 - accuracy: 0.9727 - precision: 0.9724 - recall: 0.9098 - val_loss: 0.0609 - val_accuracy: 0.9818 - val_precision: 0.9728 - val_recall: 0.9471\n", + "Epoch 172/200\n", + "18458/18458 [==============================] - 2s 131us/sample - loss: 0.0874 - accuracy: 0.9721 - precision: 0.9717 - recall: 0.9079 - val_loss: 0.0986 - val_accuracy: 0.9684 - val_precision: 0.8972 - val_recall: 0.9735\n", + "Epoch 173/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0808 - accuracy: 0.9742 - precision: 0.9724 - recall: 0.9164 - val_loss: 0.0894 - val_accuracy: 0.9727 - val_precision: 0.9146 - val_recall: 0.9716\n", + "Epoch 174/200\n", + "18458/18458 [==============================] - 3s 137us/sample - loss: 0.0875 - accuracy: 0.9709 - precision: 0.9685 - recall: 0.9058 - val_loss: 0.1509 - val_accuracy: 0.9471 - val_precision: 0.9880 - val_recall: 0.7788\n", + "Epoch 175/200\n", + "18458/18458 [==============================] - 3s 137us/sample - loss: 0.0845 - accuracy: 0.9733 - precision: 0.9739 - recall: 0.9111 - val_loss: 0.1013 - val_accuracy: 0.9666 - val_precision: 0.8897 - val_recall: 0.9754\n", + "Epoch 176/200\n", + "18458/18458 [==============================] - 3s 137us/sample - loss: 0.0906 - accuracy: 0.9718 - precision: 0.9721 - recall: 0.9063 - val_loss: 0.0845 - val_accuracy: 0.9762 - val_precision: 0.9293 - val_recall: 0.9698\n", + "Epoch 177/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0943 - accuracy: 0.9703 - precision: 0.9691 - recall: 0.9026 - val_loss: 0.1231 - val_accuracy: 0.9580 - val_precision: 0.8636 - val_recall: 0.9698\n", + "Epoch 178/200\n", + "18458/18458 [==============================] - 2s 127us/sample - loss: 0.0820 - accuracy: 0.9752 - precision: 0.9741 - recall: 0.9190 - val_loss: 0.0791 - val_accuracy: 0.9731 - val_precision: 0.9238 - val_recall: 0.9622\n", + "Epoch 179/200\n", + "18458/18458 [==============================] - 2s 128us/sample - loss: 0.0810 - accuracy: 0.9746 - precision: 0.9736 - recall: 0.9171 - val_loss: 0.0765 - val_accuracy: 0.9757 - val_precision: 0.9308 - val_recall: 0.9660\n", + "Epoch 180/200\n", + "18458/18458 [==============================] - 2s 130us/sample - loss: 0.0872 - accuracy: 0.9720 - precision: 0.9705 - recall: 0.9086 - val_loss: 0.0805 - val_accuracy: 0.9753 - val_precision: 0.9245 - val_recall: 0.9716\n", + "Epoch 181/200\n", + "18458/18458 [==============================] - 2s 130us/sample - loss: 0.0781 - accuracy: 0.9755 - precision: 0.9739 - recall: 0.9206 - val_loss: 0.1136 - val_accuracy: 0.9606 - val_precision: 0.8712 - val_recall: 0.9716\n", + "Epoch 182/200\n", + "18458/18458 [==============================] - 2s 133us/sample - loss: 0.0909 - accuracy: 0.9705 - precision: 0.9708 - recall: 0.9017 - val_loss: 0.0902 - val_accuracy: 0.9718 - val_precision: 0.9143 - val_recall: 0.9679\n", + "Epoch 183/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.0750 - accuracy: 0.9774 - precision: 0.9776 - recall: 0.9252 - val_loss: 0.0919 - val_accuracy: 0.9701 - val_precision: 0.8993 - val_recall: 0.9792\n", + "Epoch 184/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0709 - accuracy: 0.9789 - precision: 0.9778 - recall: 0.9316 - val_loss: 0.1111 - val_accuracy: 0.9640 - val_precision: 0.8805 - val_recall: 0.9754\n", + "Epoch 185/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.0779 - accuracy: 0.9749 - precision: 0.9741 - recall: 0.9176 - val_loss: 0.0660 - val_accuracy: 0.9796 - val_precision: 0.9382 - val_recall: 0.9754\n", + "Epoch 186/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0750 - accuracy: 0.9761 - precision: 0.9735 - recall: 0.9233 - val_loss: 0.1257 - val_accuracy: 0.9610 - val_precision: 0.8714 - val_recall: 0.9735\n", + "Epoch 187/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0818 - accuracy: 0.9738 - precision: 0.9719 - recall: 0.9153 - val_loss: 0.0921 - val_accuracy: 0.9675 - val_precision: 0.8982 - val_recall: 0.9679\n", + "Epoch 188/200\n", + "18458/18458 [==============================] - 3s 140us/sample - loss: 0.0838 - accuracy: 0.9730 - precision: 0.9711 - recall: 0.9123 - val_loss: 0.0624 - val_accuracy: 0.9840 - val_precision: 0.9677 - val_recall: 0.9622\n", + "Epoch 189/200\n", + "18458/18458 [==============================] - 3s 136us/sample - loss: 0.0829 - accuracy: 0.9742 - precision: 0.9729 - recall: 0.9160 - val_loss: 0.0748 - val_accuracy: 0.9766 - val_precision: 0.9342 - val_recall: 0.9660\n", + "Epoch 190/200\n", + "18458/18458 [==============================] - 3s 153us/sample - loss: 0.0881 - accuracy: 0.9717 - precision: 0.9700 - recall: 0.9079 - val_loss: 0.0644 - val_accuracy: 0.9801 - val_precision: 0.9464 - val_recall: 0.9679\n", + "Epoch 191/200\n", + "18458/18458 [==============================] - 3s 150us/sample - loss: 0.0774 - accuracy: 0.9759 - precision: 0.9756 - recall: 0.9208 - val_loss: 0.0579 - val_accuracy: 0.9840 - val_precision: 0.9624 - val_recall: 0.9679\n", + "Epoch 192/200\n", + "18458/18458 [==============================] - 3s 141us/sample - loss: 0.0717 - accuracy: 0.9779 - precision: 0.9742 - recall: 0.9307 - val_loss: 0.1076 - val_accuracy: 0.9640 - val_precision: 0.8845 - val_recall: 0.9698\n", + "Epoch 193/200\n", + "18458/18458 [==============================] - 3s 141us/sample - loss: 0.0916 - accuracy: 0.9706 - precision: 0.9692 - recall: 0.9040 - val_loss: 0.0836 - val_accuracy: 0.9731 - val_precision: 0.9162 - val_recall: 0.9716\n", + "Epoch 194/200\n", + "18458/18458 [==============================] - 3s 142us/sample - loss: 0.0653 - accuracy: 0.9797 - precision: 0.9806 - recall: 0.9321 - val_loss: 0.0641 - val_accuracy: 0.9805 - val_precision: 0.9449 - val_recall: 0.9716\n", + "Epoch 195/200\n", + "18458/18458 [==============================] - 3s 140us/sample - loss: 0.0856 - accuracy: 0.9733 - precision: 0.9709 - recall: 0.9139 - val_loss: 0.1037 - val_accuracy: 0.9662 - val_precision: 0.8881 - val_recall: 0.9754\n", + "Epoch 196/200\n", + "18458/18458 [==============================] - 3s 146us/sample - loss: 0.0813 - accuracy: 0.9735 - precision: 0.9695 - recall: 0.9162 - val_loss: 0.1329 - val_accuracy: 0.9601 - val_precision: 0.8660 - val_recall: 0.9773\n", + "Epoch 197/200\n", + "18458/18458 [==============================] - 3s 139us/sample - loss: 0.0766 - accuracy: 0.9764 - precision: 0.9766 - recall: 0.9217 - val_loss: 0.0815 - val_accuracy: 0.9705 - val_precision: 0.9080 - val_recall: 0.9698\n", + "Epoch 198/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0770 - accuracy: 0.9752 - precision: 0.9721 - recall: 0.9210 - val_loss: 0.0955 - val_accuracy: 0.9697 - val_precision: 0.9033 - val_recall: 0.9716\n", + "Epoch 199/200\n", + "18458/18458 [==============================] - 2s 135us/sample - loss: 0.0745 - accuracy: 0.9766 - precision: 0.9734 - recall: 0.9259 - val_loss: 0.0863 - val_accuracy: 0.9688 - val_precision: 0.9059 - val_recall: 0.9641\n", + "Epoch 200/200\n", + "18458/18458 [==============================] - 3s 149us/sample - loss: 0.0731 - accuracy: 0.9768 - precision: 0.9750 - recall: 0.9250 - val_loss: 0.0722 - val_accuracy: 0.9740 - val_precision: 0.9241 - val_recall: 0.9660\n" + ] + } + ], + "source": [ + "cnn.train_models(seeds=2, epochs=200)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We've got a trained CNN! What can we learn from it? Behind the scenes, $\\texttt{stella}$ creates a table of the history output by each model run. What's in your history depends on your metrics. So, for example, the default metrics are 'accuracy', 'precision', and 'recall', so in our $\\texttt{cnn.history_table}$ we see columns for each of these values from the training set as well as from the validation set (the columns beginning with 'val_')." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Table length=200\n", + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
loss_s0002accuracy_s0002precision_s0002recall_s0002val_loss_s0002val_accuracy_s0002val_precision_s0002val_recall_s0002
float64float32float32float32float64float32float32float32
0.54944718631947330.76454650.250.000230202580.52892326125992180.77069790.00.0
0.53236963607428170.76465490.00.00.49191421030737590.77069790.00.0
0.47368677965880910.78627150.976133640.094152850.386313498782346830.8465540.994350250.3327032
0.360416380687942630.86201110.965302940.42909760.31658911896852590.864325940.98648650.41398865
0.31196298172923670.88200240.95773460.521639050.241891110775322940.90160380.98089170.5822306
0.293768815881111370.894788150.94746650.58540520.26469281058731050.88816640.989169660.5179584
0.26281043544196920.905515250.95138890.630755070.217844971767689270.91374080.979651150.63705105
0.27148269458689740.90313140.942214550.62684160.24287213768130210.90680540.98159510.60491496
0.25672307294372720.90833240.93107930.65930020.21394140068255930.927178140.96401030.7088847
0.2446662752073420.9140210.92298250.692449330.22338457269280.927178140.95928750.7126654
........................
0.07736280024374990.97594540.97560980.920810340.057857050199915850.98396190.962406040.9678639
0.071674642913057220.977895740.97421690.9307090.107616177435090750.96402250.884482740.9697543
0.091626146029826690.9706360.9691510.90400550.083562462281808750.97312530.9162210.97164464
0.065316014819114390.97968360.980624850.93209020.06412372162939410.980494140.944852950.97164464
0.085622727424907380.973290740.970897560.913904250.10368110232400750.966189860.88812390.9754253
0.081318035828746250.97350740.969549360.916206240.132871094233657980.96012140.865996660.97731566
0.076597479418176840.97637880.97658540.92173110.0815108692201640.97052450.90796460.9697543
0.076995050469012780.97518690.972060260.921040530.095503759360902480.969657540.90333920.97164464
0.074479572679203660.97659550.97337850.925874770.08634232994173840.968790650.905861440.9640832
0.073052516334955260.976758060.975006040.924953940.07223986920516730.973992170.92405060.96597356
" + ], + "text/plain": [ + "\n", + " loss_s0002 accuracy_s0002 ... val_precision_s0002 val_recall_s0002\n", + " float64 float32 ... float32 float32 \n", + "------------------- -------------- ... ------------------- ----------------\n", + " 0.5494471863194733 0.7645465 ... 0.0 0.0\n", + " 0.5323696360742817 0.7646549 ... 0.0 0.0\n", + " 0.4736867796588091 0.7862715 ... 0.99435025 0.3327032\n", + "0.36041638068794263 0.8620111 ... 0.9864865 0.41398865\n", + " 0.3119629817292367 0.8820024 ... 0.9808917 0.5822306\n", + "0.29376881588111137 0.89478815 ... 0.98916966 0.5179584\n", + " 0.2628104354419692 0.90551525 ... 0.97965115 0.63705105\n", + " 0.2714826945868974 0.9031314 ... 0.9815951 0.60491496\n", + " 0.2567230729437272 0.9083324 ... 0.9640103 0.7088847\n", + " 0.244666275207342 0.914021 ... 0.9592875 0.7126654\n", + " ... ... ... ... ...\n", + " 0.0773628002437499 0.9759454 ... 0.96240604 0.9678639\n", + "0.07167464291305722 0.97789574 ... 0.88448274 0.9697543\n", + "0.09162614602982669 0.970636 ... 0.916221 0.97164464\n", + "0.06531601481911439 0.9796836 ... 0.94485295 0.97164464\n", + "0.08562272742490738 0.97329074 ... 0.8881239 0.9754253\n", + "0.08131803582874625 0.9735074 ... 0.86599666 0.97731566\n", + "0.07659747941817684 0.9763788 ... 0.9079646 0.9697543\n", + "0.07699505046901278 0.9751869 ... 0.9033392 0.97164464\n", + "0.07447957267920366 0.9765955 ... 0.90586144 0.9640832\n", + "0.07305251633495526 0.97675806 ... 0.9240506 0.96597356" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cnn.history_table" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It also keeps track of the ground truth (gt) values from your validation set flares and no-flares and what each model predicts. This table includes the TIC ID, gt label (0 = no flare; 1 = flare), tpeak (the time of the flare from the catalog), and, depending on the number of models you run, columns of the predicted labels. Each column keeps track of the random seed used to run that model." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "Table length=2307\n", + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
ticgttpeakpred_s0002
float64int64float64float32
55269690.001332.73765909321450.0053598885
201795667.011373.05379599245611.0
80453023.001374.33995117085120.00066155713
161172848.001343.17522411308070.020634037
231122278.001340.07707637362050.020502886
25132694.001355.08571870853870.009274018
31740375.011351.1931630078140.99998176
31852565.001332.31935101298250.016599169
220557560.011345.07661901770350.99853826
31740375.001380.75841382863259.603994e-05
............
5727213.001377.5554735528610.0006570381
25132999.001375.68558701758750.057495333
176955267.011335.29018551225751.0
231910796.001365.96421059494720.0011209704
231831315.011370.68592091031931.0
33837062.001372.11180698373372.2111965e-06
231017428.011361.11662942402430.999871
114794572.001357.46907674723180.012727063
139996019.001336.50187586954480.014939568
118327563.001369.85581146993420.45524606
" + ], + "text/plain": [ + "\n", + " tic gt tpeak pred_s0002 \n", + " float64 int64 float64 float32 \n", + "----------- ----- ------------------ -------------\n", + " 55269690.0 0 1332.7376590932145 0.0053598885\n", + "201795667.0 1 1373.0537959924561 1.0\n", + " 80453023.0 0 1374.3399511708512 0.00066155713\n", + "161172848.0 0 1343.1752241130807 0.020634037\n", + "231122278.0 0 1340.0770763736205 0.020502886\n", + " 25132694.0 0 1355.0857187085387 0.009274018\n", + " 31740375.0 1 1351.193163007814 0.99998176\n", + " 31852565.0 0 1332.3193510129825 0.016599169\n", + "220557560.0 1 1345.0766190177035 0.99853826\n", + " 31740375.0 0 1380.7584138286325 9.603994e-05\n", + " ... ... ... ...\n", + " 5727213.0 0 1377.555473552861 0.0006570381\n", + " 25132999.0 0 1375.6855870175875 0.057495333\n", + "176955267.0 1 1335.2901855122575 1.0\n", + "231910796.0 0 1365.9642105949472 0.0011209704\n", + "231831315.0 1 1370.6859209103193 1.0\n", + " 33837062.0 0 1372.1118069837337 2.2111965e-06\n", + "231017428.0 1 1361.1166294240243 0.999871\n", + "114794572.0 0 1357.4690767472318 0.012727063\n", + "139996019.0 0 1336.5018758695448 0.014939568\n", + "118327563.0 0 1369.8558114699342 0.45524606" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cnn.val_pred_table" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can visualize it this way, by plotting the time of flare peak versus the prediction of being a flare as determined by the CNN. This can be thought of as a probability. The points are colored by the ground truth of if that point is a flare or not as labeled in the initial catalog." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo0AAAEoCAYAAAA9lMuNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOydd5gkRdnAf1W7ezkSzibnBkTiAZLhwDlQQRAZJSoKiAoCghIVDhAF/ZSkKFEQ9ANGAVEBGUkSJH6AIAdNPGIDdxwXdm9j1ffHW3M7Oztxd8KG+j1PP7Pb0131dk9319tvvUFZa/F4PB6Px+PxeIqhGy2Ax+PxeDwej2fo45VGj8fj8Xg8Hk9JvNLo8Xg8Ho/H4ymJVxo9Ho/H4/F4PCXxSqPH4/F4PB6PpyReafR4PB6Px+PxlMQrjR6Px+PxeDyeknil0ePxeDwej2cAKKUOUEpdqpR6UCm1WClllVI3DLCt1ZVS1yil3lVKdSil3lBKXaSUml5tuQdKc6MF8Hg8Ho/H4xmm/BDYHFgKvA1sNJBGlFLrAY8AM4C/AC8C2wLHA3sppXa01i6oisSDwFsaPR6Px+PxeAbG94AQmAJ8exDtXIYojMdZa/ez1p5qrd0duBDYEDhv0JJWAeXLCHo8Ho/H4/EMDqXUbsB9wB+stYdWsN96wCvAG8B61lqT9d1k4D1AATOsta3VlLlSvKXR4/F4PB6Pp3HMcp93ZyuMANbaJcDDwARgu3oLlov3aawTSilv0vV4PB7PqMNaq+rRTx3G2bOttXNq0O6G7jMq8P3LwGxkGvyeGvRfNt7S6PF4PB6Px9M4prrPRQW+z6yfVgdZiuItjXWmXm9cHo/H4/E0kkbNsHW9t17JbVpWebUOkow8vNLo8Xg8Ho9nxNDT1y2wKEPEkJOxJE4t8H1m/cd1kKUoXmn0eDwej8czYjAMuxCCl9xnWOD7DdxnIZ/HuuGVRo/H4/F4PCMGQ/mWxiHCfe5ztlJK50m5syPQBjzaCOGy8YEwHo/H4/F4Rgxd1pRcGoFSqkUptZHLy7gca+2rwN3A2sAxObudDUwErm90jkbwyb3rRsYheIj4T3g8Ho/HU1PqPe5l+pv/zmolt11ptXeAwcumlNoP2M/9GwB7Aq8BD7p1862133fbrg28Dsyz1q6d005uGcG5wKeRHI4RsIMvI+hodMFvpdQnlVI3K6U+UEq1K6VeUkqdrZQaP/Cj8ng8Ho/HU28MtuRSRbYAvuaWPd26dbPWHVBOI87auDVwLaIsngSsB1wMbDcUFEYYIpZGpdQz9C/4XVEZHtdOoYLfsxBH034Fv5VSnwbuBVqAPwFvAbsjP97DwB7W2o4BH1xvPzV54zJxOB6Y/NCdk2dMW6ln8qe2aXsUWA3J59QKWOBDHUStJg5XBLYHOpG3mFZgTdfUczqIekwcTgfWABYAk4GFOojed31NAFYEVkbO03igB4nomgDM10FkTRxORX6Dt10bAVIGqQNo0kG00MShcu0s0UG0LOt4VnR/NiM+HOOA1d3f7yP1PVcB5rltFgKTnLzT3LFNBVZFEqb+G3gHMe/3AN3AdORmfNWdm7Y851W7c9Pl+l3T7d/sltd0EHUV+V3GAp9y+78FjHEyrAv8x33OBRa7c9XujvNtd17XR95We9yxWWAld67HAJ9wx9Hh2ugAtgKec332AB+6NmcA7wJjXT/j3DnrcG28g0TvTXF9d7u/X0Z+V4X8htPcsUx2+4xFro9OE4djXFvzs2RdrIOo3Z3LAGhy/YzFXStZ52uc63O+a399J/9KWcdogCXAMmAFt2uXOyfKbbsQ2DLrd1uig2hxod/J9Z3Zd313jB8h19ti5Dqah7xgfwSsA8Tu//nu/3WAN4GNkevvVR1EL7t7c1X3W33k9lsB+e3fQa7T/yL34crud5ru2h6DWBcmIvcOiDP8InqvAet+q8x9sKmTeT7wSSfLAndsxp2PN10fS3QQLXP39PZunx7ECjLJ/b0i8iyZ587nYh1EfaI33b2udRAtzFo3GRijg2iBicMVkOsNJ2snYHUQFcpH1wcThwGwmWvjYSf7Gu44Ix1ES0wcroaMGW3uOD9w36/ozs0yd/53RO69NieLcr/BQvf3Osi1ucSd98zf4915eBN5Zkx156jLyfWCa29N5LnyHvC2k20aMrZ0AYuyno9run5Xde0/pIOoxx3zJ5B74FUn/wbuuD9ycrUAmyD34kOu78y10+PO8WJgGyfnc+44ety+Y9w56UDu3y7X72pOnv/oIBr0mAeNszS+9/YqJbddZXW5rfzsX2UMFaVxFjJYvgLsygBqN7p2/oFkTT/OWntp1vpfIkXFL7fWfitrfRNyQ20M7Gutvd2t18DNwJeA06y15w/i8DJ9Ve3mcQ/lnwFHWEOLtaA0mB748L0WJk/rZuLkPr+rRR5aYwbRbQfyEC1EF6KYWMQvIx+ZQe5DZPAcl/Xdh8jDfHVEuaiEHuShD4Wt5zZrm3x0Ig/7dxEFZ50SfRqkwPxxOcpPM3LtfLG02GXTTq/COobix5Gh1PFWA4sMPs8jCrJGfl9D77X2EKKUTMzarwepsXok8pJ3IfB1t38TxQP0LL3Hljk+g1x/zfS/dizwAHCIDqJ3s78wcbgd8FNEmWgpfbh9MFRvpqaHyq/5wdDtljZ6le9yMcD9wI+BOUhZM4UoY/8DnIMoxZl7It9v2QM8BnxVB1HeZHkmDjdDlMRJZchTtRkza+U5Oi8ay6prdzJuwqDGx6XIS5dGzkfGH63QMb2NvBBnroV6XBfLgKuBw3Pkugv4QrEX43JolNL4ThlK42peaRwQQ0JpzKaeBb+VUrsjJXn+Za3dNae9dZE3vXnAOnaQJ6paN4+zijwGzLQWrfK0Zi3kW++pCWfqIDo384+Jw2sQBchTmjbg78DnkcG1VljEarthljXna8Bv6fvi4ikfiyhsTVn/V/LUMciL4to6iNr7fCHWz4+pXJGvGp0dcO0Fq7D97MVsul3DYw8axf/qIDp4MA00Sml88+2g5LZrrh4DXmmslCHh01glBlLwe3f3eVduY9ba15DpobWQN+d+KKXmOP/Lkssgjy2bnZCpp7wKo8hVxd48pTgl84ebYj2sgbIMN8YgFtlaKozQO72+Byz/nS7FK4yDQdHXClbpU0cjv/v+eb47igYqjABjxsIB3/qQs762Dp0do/aB+mUTh6UsvUOSLlt68QyMkaQ0llPwG/omzxzIPo1mU3x+zaHEROezB73+aJ7yaKb2U+gZmuh1m9gUhl/23xHIBPK7smxaZznyMm2lbqy1PPPQ4PQma6FtqWaITeqVQ8bvfNjRgyq5eAbGSBrgBlLwe9gUCc/iJcR/yzM0+EAHUcay/QHiG+kpn3o9vQ3wf+7vj2iwJcsDiHvC/+VZ/896C5KPd14bCyg6OwY+TL796hgO334jzjt6Ldpbh91w240EbA07jC29eAbGsLuKhxLW2jnWWlXOUsVu70Oi+Hryvbk2+G12tN2KlqxErM5f7vTGiTMsMYjyUEu6gUd0ED0J4IIvnnfrPY2hA5nJuTvPdykkmrthdLTD5XNWpbtbseVOSwbURnc3fG/f9YnfHMtT90/mzZfH0tE+rCxcc3QQDcuXYG9prB0jSWkcSMHvYVMkPIOzau0K/FkpekwPdHVCR7uivU0VUxpfKvhNeXSRf5C1SHTvAuBG4Ab3fz5JMtstgX51nrqR9DiLXV9dyMCS3U4xpbQViQTMR4/ru6PAMZSiM0/fHwIH6CD6U/ZKHUQXAt8qIks+2cjTfvb3zwFPIik6lhTZNoNFjnWwylipc9UNPA2c5z4/QoK0HnJ/v4Ao0cXOxTK3/3/dPq/Te07y0YlEuHfRG0ndVqSPRa79vTMrXMqTR1w/pkR/2diszzbktyi1bSl6kKjZepWoaEfkfhG4cwD9Zs55vvVYC4/fM5kff3NNzjlyLR6+c4o1vT0Y5Lr8ELgE2DXLSr8c9/K1Hr3uQdXGINfL8t/TWujpge4ueG3uWOYcvg7PPjKJY857m4lTyjpFueek8+rzVlncurjJdaD4wQHrceuVK7Hg/Wa6+88VZc5N9j33DhKBXUteRBJTP0nvMbQDJ+gg+mmN+64ZXmmsHSMpevpI4ErgCmvt0Xm+z6Tj+Yy19h637sfAGcDp1tp+N4hS6iXEn3F9l3hzwNQiisz50mkdRN1Z604DzkQGo8wDfm8dRP8qo70WJDXK0UiS0jeRh/tcoCPfA75IW19AUjmMR/zJHge+rIPofRcBvhWSP24CcDCST3Mh8Evg+uw0NjntfgL5HY92bXwIXAD8xuVA2wL4A+Kv2oNE5349Ny+cicNMSqXcF6duJNL2auDXOogGFTpp4nBVYAdEWW6iNxegBm7TQfRCzvYKSQEzDrGODUrxc+1NAdp0EHW5vHkBkmeyvfjeYOJwfUTpmoVMv18A3A60Zl93Jdp4DknJk48OYEaxXIomDj+JpCL5v+x8gDnbjAVORoIoxiI5V8/SQTQ/Z7vxyJTo2vQGwrQDt+ggOqSc4ykHl7fyEODXyD2Qy/M6iIr67pk4/CFwFv19mNuB05CXrH9T3hR/G/B9HUS/KdDXeUgy4dy0WnOR+2gt5DiWIc8IS28gTAcy3a8vOnk17rtlOu1t8lVzi+kcP9Hcte835u/3tf95sOLBxqVFOhHJa/gP4FIdRPNdgMalwEHI+XkeOFoH0WNZ+zYBP0de4jL5LC8BTs99lpk4vN4YDl74YbOePLUHY6GzXTFlumkDttVB9F937ayApAW7h75ppEAUvCN1EN0E8OVgvycXftAyM/eYJkzu4QcXv8kOey2mu5vuI3ba6D/xm2NfX2nVzt/84cm57wDv6SBaZOJwCpBw5/puJHfwmUjexmeQzA1PmzhcC1Gwc10uLPBXHUT7urFiByStziNIns6aD/6Nip5+at4aJbedudZbgI+erpSKlUal1D7Iw3BjYKK1dn23fmNgH0TZG7AfhE+5M3hcktbPINa3OwareAyg/08hFqfsqNguxPK0ZeZhZeJwJeRhvwK9D7xW4HIdRCcNoF+F5JDbht6BugP5HbfIzjlm4nAD4AknYwu9OQcP0UF0W5E+NkEUjmd1EL1dqYwl5N8FuAoZoAFuQQbCosmphzomDk9E8vrlKk8WOF8HUd2m9E0cfh1RHHKjG9qBTXUQvVLFvtZFru98SuMTOoi2LbH/p5CXrdz924FP6iB63cTh/cAulFYcFwNr5SbnzuprPpIMO5cet2TneO1GXoKmOln+Dez82gvjJp2wzwZ0LOs3gdUKfCZtUo+WkLFiXF7UluwCAXm2mYQoem8Vegk0cbgjUvYt9zwuBabk5GI9FlFG80XfX6yD6ASA2U0HnN7cYn/c1an7tNky1nDNgy8yZYVue9vVK/X87qerNtP7/Dk2bVK/M3F4AHAdvZbHJuBgHUS3F5D/LmA3+ir9bcBsHUQP59unHjRKaXx83lqlNmXbteYBXmmslLKnp5VwHXAbkESmD7ITIC8EfgJUlJC7Uqpc8PsB5E16F6XUF7L60IhFBeC3g1UY640Oond0EF2ng+hPtVIYTRwqE4fZkcPZHEd/i0ULYmXbImvdMcjAk/2GPBH4jonDGQMQayfE+pg9yI5FKkjsl72hDqKXnSxXIwP77cAehRRGE4fTTBw+jAzifwBeNnF4VYHjrxgThyEyXbgBMkBn0tEUVGCHEb9GXiLa6LV+GyQR9BnV6sTEYbOJw31NHJ5v4vAYV90olz3In1y5C0lCXjV0EL2GvLDkWuhbgbwWv5z9n0eUkzZ6qxktQyyor7vNjkWmmzMVPDpc+y8jCt0y9/esQgqjo1CIcBP9iwI0IwrmFB1E04FfAPapBybTk9/2PJ7e8mpVRQdRdzGF0W2zVAfRiyVmDTam9xxmo+h/XbxJ/mDENmSWAgBr1W+7u9R8pXvHjzFjjdlm1uL3F3/cFJ171NrdTmHM9DMBuHjunZuvC/ze/T/FLROBG4s8F7+MpI7L/P4fIVbPhimMjcRYVXLxDIxKUrd8B8lBdw0yjfE94EeZL621sVLqYSRR7wV5WyhAnoLfANsrpa51fy8v+I2Uc5qLWADXziPjI8AlSqk96F/wu88AZa3tUUp9HSkj+Cel1J+QB8Ie9JYRvLCSYxkNmDg8DKlIsxKwxMThT4BfZL2Nr03+SgbdSJmqp93/s8j/tt6BlJVMVyjaTPJHxU5GroNU9kodRG8A3y6z7WuQayJ7AD0IqYRxSYVy5uME+g/OY4HtTBxuqINosD6pDUMHUYeJw92R33sHxCcxpYNoYBEGeTBxOBF5CdwQUYDagJ+YOJylgyg7QvcNxC8yX3Wkd/OsGyxfdHJNQu4JDfwZsSKVRAfRWSYO/4y4UhjgZh1Ec7O+f95N3x+LXP9PIW4Vb5s4XMP1Oa+MqcgHkKnQ3NG0WFWSzLb3AfMnTOqZ2NRidR5/vUxZu6HMTPI/ixRSxvCRrHV3Isczgb7JzbuRF0oA0ib1UUInt8RyDuJTu7izQ1/6yF3Tfv3IXdOeJv+zyuomjiW/QccidYwvy/3CzUbs59xPVgDeKOQ+YuJwZeR5sydSivAXOogeyrftcMX7LNaOSpTGI4BngaOstYUSVr/MwN4oMwW/s1mX3qTa84DvUwJr7atKqa0RC8ZewOeQaemLgbOttf38oay1jymltkGskbMRBWOea+P8atSdHkmYOPwSUkkjM/U8HSknBlJGDETZ24n+02pjEYfrDK+77XIHpRYGluphHjJA5Vo5+1gAysVNd+8CfMEtuXJOQKyq1VAaNyb//diJWPSXK41Orl2BryCKxA06iP5dBRlqhlNa7nVLLfg+Uo83M/Bnrs//NXG4UZbSdBX9FfRMfe/7qi2UDqJXnM9ZAvHLfLjSFwAdRP9BXk4Kff8O4uOYu/6tCro5AZlmHofcP51uuQd5jmYrOD3A/ZnIWh1ExsThbjvstfiWy+es1s+HD1F2bqxAlkYwF3lO5Caa70HcnrKxiHJ4AvJM6FnwfvO8X5++2oUP3zltDUh+lDYpC5A2qXeQsbMPCZ18n/z5KFumrthtyf8saKa/H2UfdBB9hFgZ83LrT3bYYMy4FZ7o6VITt91jcfOM1bu2AmabOPyODqKyXmSGAz12JMX4Di3K9mlUSrUitZtPdP+fBZxprW3K2uYnwInWWl9pIYd6+3bUChOHLyAKTi4fAyu6AWQqMuU7g97BuRX4rQ6i5cq/icPNkTf47Ad1J/CUDqIdBiDbGEQR/QR9LQCLgHVKTM/ltpWpP74n8qAu9Lt9qINoIFPpuf2dC/yA/gpvO7C+Uwwy2/4KqRU7gd7o9Yt1EJ1u4nBNJGJ5FmJFuGDPVTf/L6JgTkGCCR7LDGojBROHLyPuD7ksAzbWQTQva9s9gOuR89GERG5/KXubgZLQyUnIVOFayAvSHWmTKjc6u6G4oK1jkaC0Z5BAk6WIMhkgL9RL3bK9s9T34diZn/tK9MyEq6zFuFtGAwenTeqvdTmIAWLicBriSpAJUgOZgn4V2CQ7cMbE4R+BfXHPLWOwSz5uUkftutHiRQuamxDjyV5pk3q/UH8Jnfwc8nzJVgK7gCf+8e6z30X8K3MV2GXANjqI/lvgGFZDZgB3Ql4y/0cH0XNZfX62ucXc3jzGNlsD1igOPuF9Djr+AxDL6QwdRFU1kjTKp/H+1zcoue1u60hw/nAfk+tNJep4N6XLbq1G7VMEeBrLmgXWT8I95Fyk8lbIoPMKMngejShFy9FB9CyizLyPvOV3INaefQYimLN87Ag8Sq+l5Flg50oURsf+iLV6EoUVxh5kqqoa/ApRrLP939qAP+QojDOR2tYZRTZTju0EE4e7IYP9EUjU/x493fz1c4fOfx3xNz4TSZz8+4ROjrQHZSHFTOV+p4PoHiQwYiYQ6iDaeqAKo/Pr/ZaJw5ueSm11udL2TWRm40zgj8BTCZ2cXEY7a5s4vMLE4YsmDv9h4nBWqX2qjQ6id3UQna6D6DM6iL6vg2ieDqIFiAX3G8C5iB/yuvkURoBfPXXHTdaqlUB9GTgQmDHUFUYA93zYgd5UTF3A34BdchTGdcgpfak1atx4w+cPm5/xPdwEUQgLkjapO5AZmmXIS20b4razv3On+D3yPMj4AGcCBAspjOshL+rfRVxxDgEeNXGYAHDXYKq7Sze3tzbRsayJzg7N/17yCaJnx4PcJxvma3s40mmbSi6egVGJpfHfSNDCJm56uo+lUSk1DnnDetFam6iVwMOVEWRpfBIZbHP5AAgGksbBWfXWBha5QWrQuCCIptyUKxXsfys5wTM5ZPLdzaxwGrBYn+sAP0XcJBYj094Xu7x1mW3mIL7EuS98HYjCOJOcqa2lizVf2XQTuruW77IUOCRtUnkjMYcjJg5/gAzC2dYZg6S22bxGfa6IRODPACYes+cG9tXnx6ucW7wduChtUv2mj7PaWRdJAzSR3t+uDYmcv6EWso8UEjqpAVVNa65L32Sysy1kfbcv4o/aL7fvE/dO5oeHZjyqaAfWTZvUe8X6SujkFMQ96/20SeW6oOyOKH8GyX/7QPbzNaGTLYhfdXLLnZdsdtDx76+2+Q6tudrQ68B6e666eRJJSTcl+0utDft8fQHfOffdfjMa1aBRlsa7Xss3GdaXvdYV1+DhPibXm0p8Gq9HrCEXKqVOzP5CKdWE5NdbFTi1euJ5hiCnAH+lr79iG3DKQPN+uTf5in0OS7SZN59fBRQq1diJvNH/BckN+eEg+1mOi4g9sMRmbYjVPzeQI5MQud89rTWsslYnb72yfKJgEhLUNmKURsS6l0CsRS2IEr0MmSquFWcgsytjFi1o4o0Xx+UqjCCzM4eRx+cwizn0BspkmABcbOLwxnLzYY4mEjq5IhIQ8kVAJ3TyAeDotEkNOmVSiSnaV8kTwNLZCW++3MezpAdRLIsqjWmTWgz0y6HrnqX3uKUfTmG8B5nRmfjMQ5N44ckJHHz8Bxx43AfZm66GRLq3kGfGxBhF5zLdA/y72gpjI+kZUXVLhhaVnNnLkZQ2xyG+UgcBuIjjeUgC1duttX8o2IJn2OOm9vZBLCPLEN+Zw3UQXdtIuWrA75ApoVzaEH+uc6qpMFbATeSfilUUULybWyyLPuqnS9arAkldcK4JeyJW2tOAI5G8hLWMOt8fp7wrRbFMiaVepnYjf4TyWAq7g4xanHXxAWQmoAU5d7sBjyZ0slB1r6rg0iA9TU56np4uzV+uWSl7VRu1q2gDEk2/Jc4n0lpFx7ImbrjwE3w8v8+9npnavps8yu64CYZtdl/8ApJGb8TQY3XJxTMwyj5z1toeJG3AOcjDLEQek/sjb8XnMsIuPE9+dBDdo4Nopg6iCTqINtJBlCq917DjLiTNzjJkqikTALCfbmA9Vud7900n1xK3tCFVdc4lp3RgZ4fiiXsms7iv0tgKXFtLOV0ez2+ZOHzZxOFCE4d/MXG4US371EFkdRA9ooPolzqIbtZlVLwZJMtfKqas0MN6n1yG0v30w3ZKp9eJC6xvpkgk7ChmFqJMZ1vbNWLVrVpVnyJ8Hsmf2mkt3W+9Mrbr9IPW7Xj/rbEgL3RtwJE1DoDalzy5NZtbLM8+sjy2ph34kw6iZWmT+hA4HnludIG1SttlLWPtLeccuc7m1XILGioYdMnFMzAqOnPW2m5r7RxgZSSCdickbcDK1tqzrLV+GsUzInAKyHHI9M8pSFTpajqIHmisZOD83FZHrPtHAavoILpNB9HfEPeQpbiEz4sWND/y8xPWbEMUnE5kQLseUYpryQVI0udM2cS9gced3+ZI4TKylPRTfv0mU1foZuw4k0nEvRRJlfOTEu2cT/864e2IYhKYOPyricNFJg7nmTg8oVoJ5YcxIfktsxMpXK6yauggWqSD6EBgilKseOQuG8144cmJmSCza4Dt6uAv/BF5ZhwUMH6iaUWUwweQZwQAaZO6AnmenQ/qQmvUXksWNh8w0jIpAPRYVXLxDIxKAmHOBF631l5fW5FGJiMlEMYz9DFxOA6pLPOBDqL3nf/XlxAn+LvTJlUw51+V+p+G+HLlZlvoBq7SQVRuQvUhjattfC1ybrsB1bFMvXfMnuGFb70ybhoSJHNv2qRKugK4UovnIIrAWOAOJHXSY4hFKaMotgHX6CD6bpUPZ9iQ0MmdkfOTa2lrBU5Im9RV9ZeqviR0cguk+ESftDxK2QU3P/ffL09Zoef1rKpBDaNRgTA3vrx1yW0P3EBSBvsxuTIqURo7gYustSfXVqSRyWhUGk0cqvZl6timJk5pbrZTleZh4AfZucM8Iw8Th59G8kHm8y97VgfRFnnWD1tMHK6P1Dt/G3hooAFhJg4nIJbZWAfRByYOL0VSVeX6orUDaww0M8Bwx6WLegyp1JKJPulGMjiEaZMqVi5wxJDQySORDAuZoL1lSH7IZxonVV8apTT+4eWiZd0BOGSDx4HRNSZXg0qip98hJ1zf4ynGk/dPuvtT27Z+pmWMjKHWsCeKHU0cztRBFDVYvGGNs3LtiiQy/3ehvHkN4k36JykHCb4Zcb+7DqJX6F81ZCDttNG38st25C811wFsBIyo0m/lkjYpm9DJPZD0VIch49jfgBNHi8IIkDapqxI6eTPiJtYKPDRcEsnXGj/9XDsqURpvBb6glBpvrS1aIN7j+foG+xx0Wbr1M2PH9RpdlIaeHiY2NXE6UtHEMwBcXr/7kBKOAC0mDq8GvjtQK1c10UH0nonDO5Dyc9lT1O1UWJd+lPMiEiGb6783FslYMWpJm9QSxM/42EbL0kjSJrXYxOGjiO/iWSYO30Byuz7bWMkaiw90qR2VnNmzgIXAbUqpmjsbe4Y3U1fsPq27s//bXlMTqqeH7Rog0kjiL0ggzGS3jEOU8FI5HuvJoUh93nYkAGcecIAOoqcaKtXw4mfkpHZBpiD/Ua2E8p7hjYnDTyB5Y3+ERJV/FXjEJSEftfiUO7WjEkvjs0iKg62AZ5VS7YgPSa5lw1pr16uSfJ5hyruvj10hMy2djTHQ3qrn5Ztz85TGxOEGwLr0f+GbCHwH+N+6C5UHHUTLgCNNHB6DyLZwKFhBhxM6iJ6F/VMAACAASURBVJ4zcbgP8FtgHcRv7w9IrlwPyyunzERS8DxVjfrhw4zTkOTdmfRDTUhwzJUmDv+WXU1qNNHlywTWjEqURo043L6Zsz7XnOSdCTws/LDlvofumHrIDp9dpMaN79UVujoUpked1UDRhjsTKVxnecj5HLvqGsUqbHiKoIPoXiA0cTgFWJavtN1oxcThykjS6g2Qe2KMicMbgSOy60WPcPahf3UoEMVxPUagD3E5+IowtaNspdFau3YN5fCMPOb88sQ19mld3DR59lc+0k3Nlvlxi733z9MvPPT8hx5ttHDDmOeR6d5cliHVYjwjEB1EixstwxDkemAT+gYLJYEngV83RKL6U8ik1gQsqqcgQwnjA2FqRtkpdzyDYzSm3Eno5LrAGc0tZtfxE83brUuafvyPrj/9s9FyDXdMHH4euBkZLFuQyMk3kPKGSxoomsdTF0wcTkdygeaL0o90EG1YZ5HqjonDLZDUQ/ksjffpINq9ziL1o1Epdy6au0fJbU/YWMp6j6YxuRpUMj3t8VRE2qReA45otBwjDR1Ef3cDxjeBNZApuj/WoWyep84kdLIFOBGJjp2ABEH9KG1S7zdUsMYzgcI1vSfXU5AGciT5LY09wBV1lmVIYXygS82oWGlUSo1FEtmuRv63PKy1vx+kXB6Ppwg6iF4GftBoOYYSJg73Q1L6rIck2v6hK7k4nLkJ2JPeyh+HA59L6OTGLu3MaOVd4H1grZz1XYhiPRqYRn6lMbck5aijpwGhFUqp1ZGqTnshwUnvIaVAz7bWLqygnZ2QZ/vmQIAEHD8PXGKtrXX515JUpDQqpb6BpIGYXmgT5O3PK40ej6dumDj8AhJZnFGu1gIuN3HYooPod42TbOAkdHJjZAAan7W6BVEWvgb8qhFyDQV0EFkTh4cDf6fXTaMN8eM7u4Gi1ZPbgH3pX06xBbi3/uIMHeodPa2UWg94BJiBvLS8CGwLHA/spZTa0Vq7oIx2vo3UtG9FcmO/jaRX2x/4rFLqh9ba82pzFOVRtg1XKbUXcBWiPX8fURD/ApwBpN3/KeAb1RfT4/F4ivJTcurwuv9/0gBZqsVMJM1OLhOBHessy5BDB9H9SCnBXyEVYc4EPqmDKG6kXHXkNuBxRMEAMdi0AWfrIPqgYVINAYzVJZcqcxmiMB5nrd3PWnuqtXZ34EJgQ6CkoqeUakGeY+3ATGvtYdba06y1hwFbI1koznCzvQ2jEkvjScACYAdr7RKl1C+AZ6y15wPnK6WOQPKJXVoDOT0ej6cYhXLDfsLE4RgdRPkizoc6b5A/hVk78FJ9RRma6CB6FfH5HHXoIOo2cbgnEjGeBBYDV+ogerixkjWeeibvdlbG2cj9mhu1fxbie36YUuoka22xMpcrAFOB/1hr+9zf1tq5SqkI2BSxLDcsjVklSuNWwF+stdl+NMt/GWvt1UqpwxDL42erJJ/H4/GUwxvIG30uHyJ+bsORh5FKOiF908p0A1c2RKI6ktDJzYCDkHHqz2mT8qm6ctBB1I0k9C87qb9LiD4NaB2mL1MlMRX4NGYirsvkbGvtnJx1s9zn3dbaPvlBnYHtYUSp3A64p0jbHyDPq1AptYG19uUsGUMkH+kz5Uxz15JK1PGJyNR0hnb6JxN+Evj0YIXyeDyeCjmD/gEArcCZw7USTdqkLLA7MtB0umUu8Jm0Sb3TSNlqTUInTwYeRQICTgTuSejkxY2VqnaYOJxk4nBqHfr5PPKCFQOLTBz+1sThuOJ7DT/qXEYw87JaKJF6RvkLizViJf/hMYhe9pRS6jql1E+VUr8HngL+i1iUG0ollsYYWDnr//fo/2Y/lcLJRj0ej6cm6CD6s4nDFuB8pKRcDJylg2hYW+TSJvUB8NmETk4GxqVN6sNGy1RrEjq5JhLMkq3MTACOTOjkDWmTeiKhk+OQestHIlk8/gacnDapd2shk7POHQOcDKyEDOIn6SB6fJDtrgZcB+zi/n8W+JoOohcGJ3HevrZF8rtm+/5+FTH+HFzt/hpJnZN7Z5T9QsnUM+unlWrIWptSSr2LWI6/mvXV+8DvgNcqFU4ppZE0VHl1M2vtR5W0V4nS+F/6KokPAgcqpXa21j6olPoU8GW3ncfjaTAJndTA54DPA/OB69Im9UpjpaodOohuBG40cahHWhk5l16nrBQ7zmL1RUQZSOsgmltL2WrA3uTPwTgOOa4ngNuBneiNLP8KsHtCJzdKm1Qtquf8GDiBXoVrJ+A+E4fb6yD6z0AaNHHYDDyERMdmxuKZwEMmDtfVQfTxIGXO5TT6RuLj/v+iicMZIyl4ppLo6aGU3FspdSjienILcC7inrIW8oL0K2BXRM8qp60vAqcAW1JY17NFvstLJRvfCVyklFrVWvsuknonCdyvlPoIceJUyM3l8XgaSEInm5F0JDsgjtNdwEkJnTw8bVI3N1S4GjPSFMZKMHG4G/BX928zcL6Jw6uB44bRNH0nkO837AE6Ejq5BRI9nq0ANSNK8mFUuYSgicOJwPfor3BlrJ0DnTLcE8nnlz0OK8RyegjVL4UYkj+wqgNRXEeM0mjqW3s6Y0ks5F6QWV/0JcD5LV4D/Ac4LMs/8kUXL7IhkFRK7Watvb9EWwciKcgAngbeIn8mhoqp5MxejiT0ng9grX0B2ANRJucjVSk+a629oxqCeTyeQfEVZGDN5HBrQQa9axI6mZuaxjMCMHE4FsntNskt45Df/OtIvsfhwm3kH5u6gRuBLcivVE6kNj71a5F/wNXAdm7qeiCsS98ApwwTkKCHavMo+Y9jDDCiZiB6rCq5VJFMpHMhn8XMb1nI5zHDbOR6eCBPQI0B/uX+nVmGTKcBS4FtrbVbW2u/aK1N5lvKaKsPZSuN1toua+371trOrHWPWmv3ttZubK39rLX2H5UK4PF4asJByCCaSzewc51l8dSHXcj/TJ+IVJIZFqRNaj5iMVyGDHytSODl99Mm9RKFFZxlQNV9AYF3yKPcWQumh9WWteoF7z6xyS4DaPf/yK/ELUWm4KvNT5FzlG1xbgUu0kFUiyn9hmGsKrlUkfvc52znP7gcpdRk5OW9DVHai5HJv7hyge8z68uJeA+Bm6y1T5WxbUX4Ao0ez8hkWYH1ChmAPSOPYo5c+SxaQ5a0Sf0ZmTI9FvElXDdtUpe5rx8GXqfv4GkRF4xrqi2LDqJFSBBCn+h8pUA3ocZPNNOnTO+5/zff3rVQrtBCPIJMHWbfj51IENefBiNzPnQQvQJsD9yBTKm+gkSmn1HtvhpNPZN7W2tfRWZa10aCpbI5G3lpuz47R6NSaiOl1EY52z7oPg9QSm2W/YVSagvgAOQ6L6faz2J6k75XlYprT3s8noGR0MlJwD6I79XdaZN6vYbdXYXkS821NnYgg65n5PEv8iuOS+n1bxo2pE3qIySyOHe9TejkLCRgYG/kRehp4EgXbV4LjkN80k60lrEqx1CllFVTp/f8DhcFXQ6uFOKewA8RF4IWpKraj3QQ1SR5sw6i/yLnbETTVcfk3o7vIC8Blyil9kBSY30ayeEY0V8xzwSnLb+SrLWPK6V+h1wLTyilbkUCYdYG9kPcCC6y1pYTbHwnFVyLlaAkNVCeL5Qy5I9gK4W11nplNIdMAtGhFKnlqR8JndwZCUwBGdg1cGHapE6vUX8KuAD4LhJAYNznXmmTeqwWfXoaj4nD/YA/ItfXGMTacBfwlZEYIJTQybFAU9qkcnN01oTFL210zviJ5kdNOSOc6YEbL53Rduj5D+VzCRm11Hvcy/R31BNfLbUpV27ze6B6siml1gDOQfyHV0TSEt6KJARfmE/O3L6VUgqpK384sDmSKmcx8lJ0pbX2xjJl+QQyHX4rcJq1tmovIcWUxvsZmNKItXZW6a1GF15pHL24gS2mf56uVmCftEnd13+vqvW9DpIgehHw97RJFZq29owQTByugfi0TkcsDg8Oo8jpIc07j39q9rQVu/8xfmJf/XvZUs05R649/4L77yrkjzYqaZTSeMQTXyu57dXbiBF7JIzJSqnb86yeAWwDLER8ffNFb1tr7b6V9FXQImit3a2ShjweT0F2I7//8ATgCHodqauOmwK/ulbte4YeOojeQlKiearMKmt2pl94YsL8dTdZttK4CaKHt7cpXnhqgnn6wUnVTpHjGSBVjo4eDhRzOVgBySuaj4pfJv00ssdTe8YUWJ/JyebxeIYBOojsxafsveWWuyx5avcvfrwSwN03Tu++839X/Je16qeNls8jVDPQZZgwuV4dFVUalVK7AG9Ya9+stSBKqdXp7w9wG3n8AQrsvxvlWWzWtNa+lbVfMU37MWvtdmW06fEU437y32tLkXJRHo9nmHDlC397O6GTq9x6xYzdgXWAp9Mm9WSj5fL0Uucygg0nOzK71pSyNN6HhIyfk1mhlNoX2Nda+41qCaGUWg+JPJoB/AV4EdgWOB7YSym1o7V2QYlm3nCy5mNTYH/g+WyFMYt5wLV51r9dUniPpwRpk1qS0MmjkIjmZre0Av9EXow8nhFDQie3pDc9yM1pkxpQmb2hTNqkDHL/eoYg3aPP0tgHpdQlwB3W2ruKbDMb2Ntae1wlbZdSGvOp61sg0T1VUxqByxCF8Thr7aXLO1fql0j5pvOAbxVrwFr7BjAn33dKqYw158oCu79hrc27r8dTDdIm9ceETj6GFKGfhpR6uydtUlUJUHDVQDYCPnI+bR5P3Uno5LlI7r+M28WJCZ08L21S5zVQLM8oYxROT+dyLFKpr6DSiATJHIOkkyqbhvs0OivjbMRSmOtIfBbwTeAwpdRJAzHBKqVWQorcLwN+PzhpPZ6BkzapV5FruqqYOPwqcCnyktdi4vBx4AAdRB9Wuy+PpxAJndwEOIm+NZrHA2ckdPLmtEm93BjJPKON0TY9PUDGIGnYKqLhSiOS/BLg7jz1FpcopR5GlMrtgHsG0P7XkLfe31trCxUMn6aU+gYQIKlJnrLWlir5g1JqDjVQAjyecjFxuAPwGyQSO8P2wO3us9x2JgNfQBKPp131CI+nEvYlf+UZjVxbv6ivOH1x13gAvKWDqKZVkRI6uTbiXrUl8BRwcdqkah4b4BFM3knSUUfBWSylVBOwA1BxMvyhoDRu6D4LFfN+GVEaQwamNB7lPi8vss3m5KQlUUo9CxxmrX1uAH16PPXiRPpadkAG7s1MHIY6iArdV8sxcbgzUlrM4hKPmzj8NfADn9/PUwFdSBL5XDIl/hqCicMWxBL/NVytZxOHPwZ+Vovr2/l0/gsxVrQgL29HJXRyx7RJ+fGkDoxGS6NSKtd3+BilVDLPpk3AKsBUBpCOrZyJ/1oPGlPd56IC32fW5yZGLolSaldEKX3eWvtIgc1+iRQUXxkJW98Gqfu5OXCvUmq1Svv1eOrIGuT3Pe5CrCpFMXE4Bgk+m4Rc/xOAcYgP8WeqJ6ZnFPAn8iuNAH+upyA5/Aw4DLmuJ7nlR8ChNervMtdHxuo6xv1/cY368+RgrCq5jEBWRZTBVRC9bXLW/9lLJjvNr4HvV9pJOUrj95RSr2UWxORO9rqc5dVKhagh33SfVxTawFp7krX2EWvtfGvtUmvtk9baJPKQW4kiJ9VaO8daq8pZqntYHs9y7gLyTbWNAZ4pY/9dyV+veALVDXbzjHBcIvnjkeuxDckQ0A58K21S7zRCJmdl/CZ93TdAarLn1gMeNK5856fzfKWAnavdnyc/3UaXXEYa1tqVrLUrW2tXRq63CzL/5yyBtXYTa+1x1trFlfZTzvT0NPJb+dYuJHuFMmQsiVMLfJ9ZX8gfMS9KqRWALyEBMNdXKBPAb93+NSn67fEUIqGTLcBngbUQf6h/F4myvgRxwViR3iTibcC5OojKeSDk80EDeeiMK1tojwdIm9QVCZ38K7APMhbcnjap9xso0iQKj3MlLfEDpA1RSnNZUqP+PDl4n0b2obDL36AopTSuU4tOc3jJfYYFvt/AfVZ6AjIBMNcVCYApRiby1Beg99SNhE6uCTyEvKi1INFtTyR08rNpk+pnUdRBtMDE4ebAD4DPI47Nv9RB9Ncyu3yA/JbGVuAPAzgEzygnbVLvUWR2p858jKQeWTXPd00mDvfVQfSXanWWNimb0MmrEOtmtq/xMsQQ4akDI3T6uWystX+vVdtFlUZr7bxadZxFporLbKWUzo6gVkpNRvwN24CS0cw5ZAJgBvrwylSCeW2A+3sGiYnDSUg0b6yDqJCv1EjjBmSAy1bkPg2cQoHk9S61zsluqQgdRK0mDg9H0lE1IYpqKxJ0dmul7Xk8QwkdRNbE4XHI9Z07RT0J+KOJw8N1EKWq2O2pyEzcbKATMV78nQJ5hD3VZ7QrjUqp/cvd1lp7S0VtW9v44Eil1D+QG6xQcu/LrbXfylq/EYC19sUC7e2MRK89b63dtEi/mwFzrbVdedbfi0z5HWKt/eNAjy2rTetkHt1Xcxk4ZfFKJL+mBRYA367AejYsSejkdCAmf63qN9MmtVat+jZxuA4SLDANGeDu9ZHTnpGCicNZwN/orzgCzNNBtHa1+0zo5DrIDNqLaZOqhwFmyFHvcS/T3+73fq/ktvfufiEwMsdkpZShtKugAqy1Nt9MU0GGQsodgO8gZQQvUUrtAcxFrCuzkGnpXIflue6z0I9dMgDGcSKwj1LqQeAtoAOpqrEXYnW5El8buBHcBOxOb1WJ1YAbTRzuooPoqcaJVXOK3byFfA+rgg6i18kqF+rxjCR0EN3nMgXkYy0Th7rasxkuMOj1arbpKY+eERjoUiHfLbB+GpIhZh/gFnpnestmSCiN1tpXlVJbI4PWXsDnkJDwi4GzrbULy21LKTUdqXtaTgDMbcj052aIkjIOsWrdCVxprb29wkPxDBITh2vS+1tkMw6JZD+onHYSOrkZci21Aqm0SVWcxLTepE1qfkIn5yLXY/YLUQeiSHs8noHzDhJclssHo8j9ZVQw2gNhrLW51fX6oJTaB7gZSUdVEUNCaQSw1r4FfL3MbQteEU7BzE12XGjb2xDF0TN0WAOXgDcHTeFgqeW4lBeXItdSC5Kv8OcJnfxy2qT+Vk1Ba8RhwIOI7BOApchgl9ef0ePxlM1ZSA7F7CnqVvy9NeIY7T6NpbDW/lUpdQ9wLrBnJfuOehuup/6YONQmDk82cfieicMOE4cPmjjc2sThROA8xEE9l04k0rcUewCHIwNDRvEaD9yY0MkhHwnvKkasgzjTX4wEdG2WNqmBZADweDwOHUTXIT7yHyIvph8BpyNlOD0jCGtVycXDC/QG/JbNkLE0ekYP7W3qV80t9ojmluUBHzsB9yMBGPkS41okgv6XZTR/GPmd3XuQCidVS69RK9ImtRCxlno8niqig+gKE4dXIqnU2vy09MjEWxrLYgMKx4UUpKClUSn1f0qpb2b9/1UXVezxDJizPjd7K635dpbCCIC1jEOSqedLKN0FzNRB9HYZXRS7CfyTxOMZ5eggsjqIlnqFceTiLY2FUUqtqJQ6FfgCEoBcEcUsjVvQN2P+tUieqdyi2J5RgvMXTACHuFU3AP8sUq2kH0s+brqqq1MxZlzfXZQqGjlsdRCVmy/zBiRVT+4UdxOQLldOj8fjaSQuBddFwJeR59edwLFpk3qroYINA3rM6FUKAZRShaqBNSNZSRSwGMn/WxHFlMYFSO1ljyfDb4BD6Z3+/RISof7t3A0TOrkhsCWSHP0JVylh3OTp4zZrHtNfxzQ9oJtYAKxAX4ugQXJmlksa+KOTcyxipbTAoWmTaq2gHY/H42kICZ3UiA/3hvTmbf08sG1CJ9f3z7LijPboaSRVYT5jjgEWAo8j+a8rrglfTGl8BjhMKfUOkv4GYAul1FdLNWqt/X2lgniGNgmd3JL+/oITga8mdPLytEk947ZrAW5Eaid3Iy4QUUInE8CSJQubzX23TG/abb+FjJvQe013dirGjbfHILkxxyIPyna3lM7U6nBWz6MTOnkFknJnKXCzK23m8Xg8w4FZSFWZbDeeJmQG5UDg6gbINGwYzdPPANbarWvVdjGl8VTgDuCn9Gqs+7qlEMpt65XGkcde5K9UMgZREJ9x/5/s/s9Oe7QJcHXapPZL6OQ/Ljl19T0XfdTUss/hCxg3wfDWy2Nt6rIZfz75pntuMnH4MHAM4h7xBHCZDqK4UmHTJvUUMJITgXs8npHLJ8mf0H8SksfVU4TRHgjjyggusNaWk3GkIgoqjdbap5RS6wPbIhU5rkUiT4d89KmnJixFpnpzr5kuYEnW/9+if57MMcBnEzo5ATiqp1s9dM1PVp1xzU9WaWlqorunR80Fvn7yTeCCXU6r0TF4PB7PcGAu8mzNDQxcCjxXf3GGF0OgOnKjuRnJSVo/pRHAWrsEuAdAKXUt8Iy19rpqC+EZFqSAC/Kst+67DPnS3YBYocekTSp2/o57glq/p4f/AA9UEkwzWjFxOA1YBXhdB1F7o+XxeEYDJg5DJBXYO8D9dYq6vheYhxQ0yMzw9CBKoy9tW4LRPj0NfID4L1adSvI0rgP4BMOjFKfsHQT8AXl4gfjYHJw2qfezNv0bcDD9r62XMgmq0ybVg7g+eMrAxOFYpI76V5Ak58rE4Tk6iH7eWMk8tcJlKtgamaaciwsma6xUowsTh03AdcD+yDPPAvNNHO6mg+jNWvadNimT0Mld6I2ebkaemd/1QTCl8bWn+SewSy0aVnYAdlylVAuwEVL8ehEw11rbVWXZRhRKKQvFSyAOB1xVlc8gD9B7ch9gCZ1cFfElnIJYHTuQaZY90ib1eJ3FHRGYOLwCiQbPnvZvBY7UQXRjY6Ty1IqETk4C/gFsjtxnCpmSnJ02qSXF9vVUDxOHRwO/QAL+MvQAT+ogqriSxmik3uNepr+Nbz2r5LZzvyjVI4f7mJwPpdTqwGNImeRT3axxddquRGlUSk1BClwfRl9fi3Yk9cqp1lpvjczDSFEayyGhk1OBbwA7Ai8Cv02bVDmJuT05mDgcj5Q7y5f0/DkdRN4pfhiQ0MmVgSOQIIYngGtd5Z982/4WKYU5Nmt1B3B92qSOqrGoox6XH/FrO+/98Zmbbb90+h4HLGTi5D4zfe3AejqI3m2MhMOHRimNG90yp+S2L+4v21RLNqeonYMEja6IZJ25DTjbWpv3Xi/S1lbA9xFr4crILO+LwNXlZKdRSt2O5NmeiRgYXgJi+qfhsdbaYsHN/dsuV2l0CuPDSCTsEuBp5KSsgkS6TkFqGe5grS2UWHLUMpqURk/1MHEYAK+TX2mcr4No5TqL5KmQhE5ujFReGItYi9uQB/m2aZN6I8/2S+lr3cqwLG1ShXyGPVUgoZMh8G/kfpswdnwP4ycaLr3jZWasvnwyrQ3YXAfRK42Sc7jQKKVxwz+fXXLbl74k1shqyKaUWg+5x2cgwcIvIkHEsxCFbUdr7YIy2zoWuBjJp/h3xJd2BeBTwNvW2gPLaKNcf0ZrrS1WWKMflfg0noYojL8Bzsi2KCqlpgI/RlKlnIaPfvV4qsUHSOb+XKXRMoASUJ6GcAUwld6k9RMQBfJCpHpRLmPzrAMYk9BJ5X0ba8rliNuVBuhY1kRXp+a3c1blzKvmZbZZALzaIPk8ZdCAG+QyRGE8zlp7aWalUuqXSJ7h85DMIkVRSs0GLkGKVByQO63sXAPLYXKZ21VMJd6i+wOPWmuPyZ2CttYustZ+F3lD+1I1BfR4RjMuUvN4xLqRoQexVJ3eEKE8ZZPQyWZgB/rXPW8C9iyw2z/pH/loEB9irzDWiIRONiHTgX3GRdOjeOLeKSBBaK3AV3UQ+d9hCGONKrlUC2dlnA28Afw65+uzkGvmMKVUvtmDXH4OLAMOzueHWCx2RCm1ppsRxlrbWu5S3lH2UomlcS3gzyW2eYAKqnd4PKMNVzHnCMRnzSKVHa5Nm1R3oX10EN1o4vB94AxgXcTCeK4OopdqL7FnkBikMlK+xPgdBfY5FnFiH49YJdsQP7pjayGgZzmWAr+VkmC+nwFX1jpy2jN46uwFNst93m2t7fOyZ61dopR6GFEqt8OlMMyHUupTiM/zbcBHSqlZiE+iRYpn3Jfbfg6vA3OAcwd4HGVRidLYiphfi7EyfS0iHo/H4dKo/B2xPGXeOjcF9kno5H7FrEg6iO4D7qu9lJ5q4lKnpIAD6Dvt3I4UTMi3z6sJndwA+DqwFeI//ru0SX1UY3HLwsThSsAXkIolf3cJ+Yc97rf6E/JbZSuO7R3t+kodRD9qkGieCqkkKUzGD7JMzrbWzslZt6H7jArs8zKiNIYUURqBbdznB8D99E+Z85xSan9rbSFfWkX/GY2qU4nS+ASQVEpdYK19OfdLZ6L9MjJF7fF4+jML2J6+QQ4TgT2Qt1B/74xMjkEGjE8iVgONWBLPKLSDi6z+ZV2kqwAThwcgZWINMkBdZOLwVB1EFzdWsqpxLPI7rU/vAPws3k9/WFFnS+NU97mowPeZ9dNKtJMxyh2BBL98HngI+ARwJpJ27e9KqU2ttZ0DF3dwVKI0/hy4G3hCKXUpYvV4Dwnr3g34LlIX83+qLKNnlJHQydWQh/Rs5Br7edqk/tZYqarCLuSPih3rvvNKY51I6OSWSBBKF3Bz2qRqNtWfNqlFCZ38NBJNGQLPp03q6Vr1VyuchfH39C8T+lMTh2kdRC80QKyqkjaphQmd3ApJF7Yh8DzwuPclHWYMzyQlGV/aJuBAa21mPFislPoqkht7ayRupGFVgcpWGq219yilvoOEgp9OXyd8hTx8j7XW/rO6InpGEy45+DPI21sLsAEwM6GTP0yb1EUNFW7wfIA4OeemTWl333nqQEInf4ZY/8Yilr/TEjp5atqkLqlVn07peMwtw5V9yV+arAU4ELGGDHvcb/WQWzzDkEqmp6uQcidjSZxa4PvM+lI5rDPfx1kKIyB5cZRSf0GUxm0prDTW/OWmEksj1trLoaXcowAAIABJREFUlVJ3Ism9t0ROxiLE5+YGa+28Yvt7PGXwAyTnZ3ZqgYnAjxM6eUXapIazz+yN5K/f3QP8qZwGXCDNScDRiMXnVuCstEl5pbMMEjo5E1EYsxX3ZuCChE7e4pPQF6WF/D5TmvyBPh5PQ6hmdHQZZGYpwgLfb+A+C/k85rZTSLnMJAjPtfRn8z2l1NdL9JONtdauV8H2lSmNroc3kZxDHk8t+Az5B6AeYGOkROGwJG1SHyV0ck8ghSjGIA+IL1ZQHi4FJOhVeo4APp/QyU+mTWppVQUemexP/kTpBtgb+G19xRlW/A3JLZlLO3BLnWXxeApTX2eCTIDibKWUzo5wVkpNRlwd2oBHS7TzKBJwvLZSamKedDifcp+vF2ljGqV9J7Op+EyN+qreniHHWwXWjwHer6cgtSBtUo8AawA7Iw+TNdMm9WQ5+yZ0chP6Kowg1p8VgEOqLOpIpYf8U6zWfecpgIuSPg1xsehGzmMbkobG15WvASYOlYnDHU0cnm/i8IcmDtdttEzDAWtVyaV6fdlXkXiPtZFZjGzORmbKrs9WApVSGymlNspppw1JwTYO+LFSSmVtvymSpq2b4rNSFwHrVLBUfD1VbGn0eGrMz4Fd6asYdQAPjpSpw7RJGcRvs1Jmkl/hmYgooZcPRq5Rwo1ITdfcZ59Gyn95iqCD6CITh3cDByEvLLd4hbE2mDhUwO+QFEATkLiB000cHq2D6PqGCjfUqX/Y0neQ/LmXKKX2AOYCn0YyZkT0z5Qw133maq8/QoIiTwC2dzkeP0HvDMkJTkktxMe1dhP0lkbPkCJtUvchkfiLkRrn7cC9SDqn0c488j8O2yntL+MB0ib1AvJgbkcsZpnE2Ud6v9Dy0EH0gg6iH+kgOtUrjDVlNqIwTkSUizGIP9vlJg4rmYIchagylurhFLmtkdyrn0b8ztdDAoe3K7futLV2MWIA+Akyg3Qs4jbzELCntbbhqa28pdEz5Eib1DUJnbwBcSz+MG1Sw35aukr8C8nftR59A4W6gasaItEwJG1Sv3AJt/dBzt1t/hrzDEEOpH+mBRCL42zg5vqKM4woVjelRlhr30IS8pezbUGt1Vq7FLFMFszj2ki80ugZkqRNqhPJkVYRJg4z9WOnA//SQTS/2rI1irRJ2YROzgKuQ3KjArwKHJ42qXcbJtgwJG1Sb9K/TqzHM5ToQmYW8ikYBWsQexiueRqHBV5p9IwYTBxuAqTpTaA9xsTh2TqIzm+gWFUlbVIxsGdCJ6cAY9Mm9WGjZfI0joRObohUE3oXuDdtUj6YZ+RwHRLglmttbEICLzwFqCRP4whiFvBGrTtRtsyzq5Rqsdb6t5sBkqlvWYVEop48mDjUiM/favR9M28F9tZBdH8j5PJ4akFCJ5sQpWJ/JOrbInncdk2b1BsNFM1TRUwc/hjxj8tE92vgSzqI7mqoYGVS73Ev09+aV+VLh9uXN488BfBjcqVUEgjzjlLqAqXU+jWTxuMZONshyeZzHwATgG/XXxyPp6YcAeyHBEZMAiYjL0xlJYn3DA90EP0Qyc93MnAcsPpwURgbilWlF8+AqGR6WiPVOr6vlLoXSYJ7m7XWT4d4hgKTye/+rKgs2anHUxYJnVTAt4BTgZWRxPMnpU2qHhHF36F/HfMmYJOETq6RNqlC+U49BUjopAb2RCKW24Br0ybV8GICOoheBX6Vuz6hk9ORMXl/JNvEJcAffJ1sUKP+DNSOSiyNqwKHAg8CeyCRW28rpc5TSq1dfdE8nop4hPyVZFrxUYae2jAHySu6JmLx2wm4L6GTm9eh70KlxHqKfOcpgHsBuAl5VnwDmZ34V0InT2yoYAVI6OQk4EngRGBDYBvEkNPwlCxDAqNKL54BUbbSaK3ttNb+0Vq7G7ARknm8GakQ8IpS6g6l1L5KKZ/70VN3dBAtAY5HLAQZ63cr8F/ghkbJ5RmZJHRyApIkPNfaNw44qw4i3ITkl8zlY+DlShpK6OTEhE5umdDJGVWRbHgyG9gLmeoHsdpOAM5L6GQwkAYTOrlSQifPS+jkMwmdvCuhk7OrJCtIdZAAGJu1biJwVEInV69iP8MTW8biGRADUvCstZG19iTEhyZjfdwLqT/6plJqjlJq1UraVEqtrpS6Rin1rlKqQyn1hlLqIqXU9ArauF8pZYss+WrOopT6pFLqZqXUB0qpdqXUS0qps5VS/o19GKGD6EokMerVwK2ItWBnHUQdDRWsBAmdXC+hkz9J6OTvEzp5cEIn81lMPUOLNclfdlADW9ah//9BatBm6o13IC9Jh5Y7PZnQSZXQyR8BHwL3A/MSOplyCvFoY396FcZsupEp64pI6OSKwLNIEMvmro1bEjp5wmCEzGI2+XM4dgLbVqmP4YtXGmvGoFLuWGs7lVJ/B1YCNkCmsFcFzgROU0r9BjjFWlt00FZKrYdML85ASnm9iFz4xwN7KaV2LDejuuPsAuu78/T9aaTiSAviRP4WsLs7hj2UUnuUkt8zdNBB9H/A0Y2Wo1wSOrk3MiXWjFyDXwROSujkzmmTamuocJ5ivEPfBOsZLPL8qilpk1qc0MmtgK8gz6s3gKsq9GU8GDgFmc7OvCB/HrgMsWQNCxI6uSZS1nAycAfw7wH49S1FXgKactZbRBmvlOORih65lsDzEjp5VdqklubfrWzeQMazfOUwfc5WrxTWjAErjUqp7ZDB+cvIlEzGEfcaYCvE1+K7yE1TKnr1MkRhPM5ae2lWH78Evgechzicl4W1dk6Zx9CE1PacAOxrrb3drdfIQP4l1/+IyfM3GFwt1JlILcwndBD5smuDIKGTLUjalGyL9iTE/eNo4MJGyOUpTdqkliR08mqkAkS2xWcZcG6dZGhHrp/rBtjEqfSfXh8PHJjQyWPSJjUQZamuJHQyiRy/RnyaT0Asel+rUHG8FxmzcmlCFNFK+SwyLubShVgeHx5Am9lchkTQZ4/h3cjLzGODbHv4M8qio5VSZw5wV2utreh5VZHSqJSaDByGDGifQiJTn0Yu4D9aa5e5Tf+jlLoeuAuJRCuoNDor42zkzSm3QsNZwDeBw5RSJ1lrq/0Q2xXYGPhXRmEEsNYapdTJiNL4LaXUBbbchJYjFBOHqyEJZddC3sjHmDi8EDhDB9GoPjf/z955h8dRXX34vVcukm0w1cj0ZmEgoScxGAwGLphekqEkdAihl0AKJYAJJeBAICT0TgiQgY8SSmAIpgRCSUggBGwRegKig4vcpLnfH+cOWs3OrHZWK63KvM+zj+zZ3Zm7uzNzzz3ld7rBBiR7q0YgXqDcaHQY7TUh1+qMIPRn1no8jhOALxEplBFIuPjYIPSfqemoyme5lO0Wka/q00aj0d5iSK/fwkXXSMRbfzvZjL1DSe6+8lGFHv/3U/Y3DOj2YjsI/RlGe3shTo8GZC5/Gfh2Xj09KKunz0rYVvgtqITtyv27Z4xGpdR1iFdxBJI/cwtwubU2UV7CWtuulHocCZ2UYrL7+4i1tpNkirV2tlLqacSonAD8ucyx7g2shuR3vAY8lhJijsZWpHtlrX1TKdWM9D9eHWnXNpi5G/kuCs+Z4xCZkbtqMqL+TyvpecV9esLuLYz26pG0ka2R63mY0d7jyOQ4r9R7e5og9NuA01xe4DDn+esXOHHwtNzZL4CWXhxOpWxDQsoR4q3/HtmMxm1Jbte3otHeqArCyRe7fRZ6oRcBLwehn6lQKY0g9B8w2huLVE/PzmWWChh8RuPkhG0nAjsCtyI5yy1I8dRkxCnxAFLQnIksnsaDEcPpSuAGa+1nZbznceDsLl6zlvvbnPL864jR2ESZRiOyyizkI6XU0dbauPBtOcduco8io1EpdRa9UylZU8KWptUQz3L8fBmJGI650VgZryLhpHEUd7G5vCYj6nucjxgH9XR4lCYjKSPH12pQhQShH5JcydyXmUL6/f9G95n6OmkawZbsvZlnITmRScfInNMehP4TRnsnAhch+rFDkajcHln31cVx2pH7SE4Bg83TaK19ovD/SqkDAANMsNa+GHv5TUqp3wBPIsXLmchSPT3FWjvOWntRmQYj1tqnrbVpRSkRo93fL1Oej7aXI9B8L7ALsCIywYxHJp0lgDuUUlN68NgDmdEkr+hBkr1zKsCFkXZFVoCzkGT8KE/Nr+HQ+hKHUpwbVo9o6eVUzgYk6zlaxAPeH3iU5DmsFbg5475+Q/Hnng/cEYR+Re1zg9C/GsnV3xZYNwj9iUHo53ngvUHeEeZE4I4EgxEAa+3fkLqNE7PuOIunsVEptZ619uW0FyilvgZsZK3NesFWBWttPAdsJnCqUup94DLEgMxbMGXn3ySv6udTwUolp4Mg9Ge66s9tkQnmL0Hov1njYfUl0uRfRhjtqcGQv+WEp5cB5gehP7tKu30T8WjHvWtz3HN9niD05xntfQe5B1mkaMUCVwHTM+7ul8A6gId4Fochih5Hd3eMwAvd2UdOBQz4u0KXrEXX6RnvI+d7JrIYjTciyZapRiOwGxKOzmI0Rt680SnPR9u/yLDPONciRQUbKKUWs9ZGN95uHdtVaZ9VzgCiRur9Ed3YvChsafo+4gEbjtycW4EPqSAnIqczLjcuX8wk8xRSsBZP5H5qkBiMmyLFDqu5/z8KHBiE/ifd3PXdSOh0BB0yM+2IIdlvFoJB6D/sxKwjncWHg9DPLHnkrsEDjPZOQ1Jx3uxDBVc5WRnwd4YumQVM7OI1m9Oh81o23dJpTCBa6WUhujCbUp4f5/6m5R12ibV2vlJqNrAkkocXGY09fuyBgm5svjNsaXodkVFaCXgIuM51YsnJ6SmOBv6KLFaGI16gBcAxtRxUb+A80I/QWXTaAI8a7W3YHaM5CP35RnubIQbp5m7zM8BBtS4wykoQ+p8jgv7V2Nd7iFZvTj9G9YeM3J7lAeAgpdQvgakFjrJIBecsxKi8IeuOq200NgGfZ3xPFEbYTimlCyuo3YebiHi1nq10UEqptRCDcTZQuEJ/DDgNSQo/P/ae1ZHP8w79JFzT0+jG5peAw2o9jpz+iav03BMx/u4PQr/LxVgQ+q8a7a2NGI8bAy8Cvw1C/389Oti+wREUSzINBdZAmh90S48vCP23gclGeyPd//tVxb7R3hBkfmhA0jq6K5idM1DIPY2nAFshOYuHKaX+iUQGl0PymRdH7JpTs+64pNGolLo+tml3pdSqCS+tQ9pqbYFYuGVjrX1DKfUIUiF9NJJ7GDEV8QxeVajRqJQa7947o2DbasCX8SIdpdSydFjTt1trCws6nkAkeSYppXaNiXtf4F5z5WDXaMzJ6S5Ge/sgwv8gxQvnGO1dGIT+WSmvH4WkuywJ/DkI/dN6ZaB9i/F07igSESJ6qVURce5vxiKA0d4mSM5W9P0MMdo7PAj9W2s4rJw+Qv9NBqsO1tqPlFLfRJxh3wUmFTzdClwDnJqx0x4AqpQ9pFQnJ2+SUCmx558D9rPWZvLMJbQRfA34FiKt0QxsVvjhovxAaztKoJRSByFyQH9BLOjPEEN2RyQ38W+AsdZ2yk9MaCP4LiLxsQmi2l+VNoJJYx7MGO0NBzZF8qj+6nKKcgYgrg/vexRX67YCk4LQ/3vs9ZsiOZ6KjoXtjcDRfT2P0WhPI5qSayD5389WOmYn2XIOxcVA84H1qqX3199w944PkAVFIfOADfNcxL5Db8970fHWuODiLl/7xk+kAdBAn5OVUkOQBehopI5jRsx5lomuJHdWc4/VkRv4JQXbCh8rA4tbazfLajCCeBsRI+1GxFg8CbnpXoroDJVjDf8d0WdcDunkchISdv4XoiU4MW4wumM/B3wDMVa3Q9y5o5GCHpP3na4+Rns7Iq7ye4H7gQ9cflXOwGQnkqvv65FV8Fe4kON9SPhkMTr6Ih+AyGn1WYz2lkWUBv4PEXd+BHgqCv9WwPXITb5Q8qUVuHewGoyOHSjuEQ2ywMilmHLEhdXVY5BgrW2z1r7iJBBf6Y7BCF2Ep62170T/VkpNBaYXbqsm1tr3EAHxcl5btDKw1v4LOKjCY79KBaXnOdkx2lsB0SCMe0/+ZLS3QhUlRXL6DqUWp/FreVOSO5WMRDQb70t4rq9wNbLYLcxD3BhZgJ6UdWdB6H9ptBe9f1c6RN8Hu2LBaJLPqaHA0r08lpw+yGAPT/ckZRfClCHSnZNTDt8l+YavkG4JNdH4zOlRHgCuSNg+HxGYLSSpF3dEWtu7mmO0NwzxqMbHXw8cSAVGI0AQ+h8A33ePHGE6yXPXHOCPvTyWnD5IXj0NSqlxSNesbyKpHEneeWutXSPLflONRqXUyu6f/3N9pFdOe23CKN7NMoicQcXSJCf3D6U4RylnABCE/sdGe0cihqNCbl6LgCuC0I+rIjyTspu5wO+qOS7Xf9lDFjILENmWhyvMQdSke1QrNnbDliYNWN3YnPtOHEHov2u0dzEyIY5Azqm5SE79/bUcW04fYZBfLUqpTZGOSQ1IN7cPSe7qljmfs1TY6G3gLSTcUvj/rh65PE1OKQLkBh8npPze4jn9jCD0bwTWBn6GqCJMCEL/5ITXzQf2Q3L3FiC3/zlIH/s7qjUeV7ByLyL8vwvwHaQQ7peV7M+N+1mKp6s2d5xMhC1N64QtTY8jxnVr2NJ0VdjSNKr0uwYPrpp+dyTV5QHgSGCK68WcM9jJcxrPR5wzRwAjrLUrWWtXS3pk3XFq9bRS6kbkq/2ptfbDgv93ibW2rNzEwURePS24lmj3IZXxUYHAXOD2IPRzDcgcAIz2VkKMx6WRSuo3kdZYM6vRZtFob3vESIwbYvOArweh/0YF+xyPeEqHIx6wOUghyyZB6LeUu5+wpWk5pPHA4nR4AuYDz+nG5q2yjisnp1bUqnq66eyuq6ebzxi41dNKqbnAH621+1R736nhaWvtQaX+n5NTCUHoW6O93YF9kIrYRUhY8J6aDiynT+E6c5zv5FXuQJQNFgLDjPYeAfYOQr87ygY70LFoKcQifcAzG41B6M8w2lsD2B/pY/wCshjKqoP4A8TwLJzM6oFNwpam9Z3Ifk5OTk4aCxH5wKpT7Y4wOTld4kJIt7pHTk4pzkMMxkh6B/f/86iwuMTxObJgiecbttPRkz4zrqXdr7sxLoANESMxTjuit5YbjTk5pRj44eeueAa5j1SdrnQac3JycmrJ9ykWBW+g+9XEt5CsHWmpfQXuC0g4Os4QRAcyJyenBCrs+jHAORXYTCm1f7V3XKp6Ot5CsFystfbQCt+bk5OTU0iaMHalgtkABKH/ptHeAUhDgTYkFNwG7NIH2updA5yMeEGjhf184Gnd2PxKzUaVk9NfqIGnUSm1IqKpOgXJxf4ASbuaaq39vMJ9TkIkpjRwrrX29DLfuhvS6e5GpdRhSPOTouYmiL328yxjKhWePijLjgoHgYjw5uTk5HSXp4HN6ZzfZ5F2od0iCP07jfYeBLZAcoD+EoT+oi7e1uPoxuaPw5ambyFh7q0Rg/F6xHuQ0w3ClqZhgNKNzXmnrwFMb4t7J7RCnoHoIx4PTFFKTcza51kptRhwE6IkkVU54ayCf2/hHklYoGpGY+ZS7JycnJwqcwxiIA5HPG8LESmeY6ux8yD0W4GHq7GvaqIbm19HinUy44qHVgQ+DEJ/TlUH1k8JW5pWROSVtnH/fxw4TDc290iHs5wa0/uexssRg/E4a+1l0Ual1MVIa+JzEfmbLFyKdD86370/C5Mzvr5sUiV3cqpLLrmTk1MZRnsrI/3jNwJeBH4dhH7eQCCGk7M6GdHCjETUrwdOCEK/W/1m+zPOu/gGMJaOrhjtwEfA6rqxOSl/NKcK1EpyZ+3Tupbcee3c6kjuOC/jfxAt6zWstWHBc4shYWoFjLHWlpX6opTaDQlt7484924gW3i6x8irp3Ny+ilGezsD04BxyI3pzCD0K81F/oqwpakOpzPYFzqROAOxSAg8p4j9gDPpnO95MKI9+aOajKhvsBvisSlso1YHLAZ8m1zFYeCRodAlMjTLZKq19qzYtsir90ihwQhgrZ2tlHoaUXyYQBkNLJRSY5C85nustb9TSh2UYXw9Tmr1tFJqZfeoi/2/y0fvDT8nZ3BitDcF0S8cj0yAKwKXGe0dVek+w5YmHbY0nYnI0XwG/C9safpuNcab0yucTnGB0AjgSKO9Uj29BzrjkO8hzkj3XM4AQ9muH1VkLfe3OeX5193fpjL3dw1im2UNZ/cKeRvBnJz+yXkUT4QjgLNdi7xKmGotP0I8MEOAsYsWqptfuX+DvMNT/6AxZftQullt3s95GSkmiDOHXPNyYNK7bQRHu79p+q7R9iW62pFS6hBgV+Aoa+2HlQ5IKRUqpdrLeGROWykVnr4Z+Wq/jP0/JycRo71JSO/erwHvA1OD0L+ltqMasKR5SBZHKu1mZdlZ2NI0FDhBqc7GxdBhtm54Q3iN0d6fgtD/oLKh5vQSf0OqreN8TDcEywcADyHdMdZECqpACqrep/aanDk9QQZLpa/UGSilVgUuAXxr7R+6ubsnSf4WlkA8ng3IgilJhqckeRvBnKpgtDcR6REcCTGvAVxhtLdEEPqXpb8zp0LeBNZL2D7HPbKypLUMVQm3zzErLKoDTgB+UsF+y8ZobwjQHoR+vjitjB8jk0UDHRJFrcDxg/k71Y3N7WFL0+ZIFeo+yHfzB+CnurF50BYIDWR6WXInWpCNTnk+2t6VgXY9kn9ccYpRhLV2q7TnXHHOr4DNgD2z7jvvCJNTLc6luHPHSCRcmhdcVZ9TKQ65tSLe3Ur6HXza3sbCpCfeerUeYKsK9lkWRnvfNtp7C/H+fGy0d6KrBM7JQBD6f0cmgvuA/wJPIGLld9V0YH0A3dj8hW5sPlI3Ni+pG5uX0I3Nh+vG5s9qPa6cHqJ3w9Mz3d+0nMUoKpSW8xixESLb87FSykYPpHIa4DS37Z7uDNZaOxs4HGlmkFXKp7LqaaXUSkhfw9GIlf0Pa+17lewrZ8Dw9ZTt9Yg6fsX5GTnFBKH/gNHefkg6wGrI93s2cGUl+9ONze0f/OXr05ZdfuHZ9SM67qjzWxU3/GJsiEhKVB2jvR2R1JcoP3NpRGx2GHBBTxyzN3BG70RgFeDvQejP6I3jBqH/ErB7bxwrp39htDcSsE6bdEDTy20Cp7u/2ymldILkzkRkQf9sF/spvA8WMg6YBPwT6ezyj+4O2FobKqWmAx4ZPZuZjEal1DhExLIob0Yp9RhwtLW2K2s6Z2DyJrBUwvY2pBo3p8oEoX83cLfRnqpG+HGVzf/188sO3crb9eBPv7ZM4yL11ox6rjtnLK/+beR8xDjtCc6h+EY5EjjFaO+XQegn9Yfu0xjtLYe08FoZ8WkMMdp7ANh3MOslDmaM9jYApgIbIwuwqUHoTy/9rqodexzirfqW+/8TwMFB6A9cR08vhqettW8opR5BZHWOBgrTsaYi97OrCjUalVLj3XtnFOznuKT9O8mdScADVdZprAeWzPqmso1GpdSaSJucpRGh1L8ALUjF3uaI0v5flFKbWWt7xCuR06c5A7iTzgbAXODiIPQTw5451aGa+Wr33bDs5vfdsOwNwE6I2tnnwA+C0O/26jaFNVK2NyCRjP4YQrwZ8Q4UytzsiHSGmFaTEfUiRntbA6cBqyJzxtlB6L9e8k2VH2soMlEfisxntwC/CkJ/Xk8crxKM9r4BPE5HrukKwP1Ge/sHof9/PXzsUchvsBQd6WhbAs8Y7a3eF9pm9gQ1yG05Cvmef62U2gZ4DTHSJyNh6dNir3/N/a1JGo4zWj0qiCBlyWk8HzEYjwfWstYebK09xVp7MKJTdCKwDCIFkjPICEL/IURI+L9It4VZwC+QlVZOPyEI/VlB6H8bya1pAlYKQv/+HjxkWth2Lv2w4tdobzSS/xnXRRxBH9VdqyZGe99FKpK3BlYH9gX+brQ3vgeOpZD8zXMRxYbxiFbl40Z7daXe28tciPz+hQbCCODXvZC7uxfiUSqc64cgC7JdevjYtaN3cxqx1r4BbALciBiLJyEL4kuBCVn7TncXpdT1KY+bXVj6ZeQc6Lp1Tows4eltgAcL+ypGuBj+pUqp7YFtsw4iZ2AQhP4fjPZ85Ca1oMKCjJw+QBD6s8go21MhpyBGRqGHuhU4oz+GphFJl7QpKSlfacDgDLVL6fw565Dw3DnAd6p8yAnAFrHjNQDrIJ7dviKns3HK9jGIJmpPXmdrIhJcceoRo35A0svV0wC4uo6yNG2zyPxYa29EjNEsHNTF8zOAadbaG7p4XRFZjMZhSCJmKf6BXMQ5gxQXKk0MDRntjUWKG3YBFiDK9+cEob+g90aY05cIQv8xo709kLDteKQd4llB6N9Y04FVzsdII4S1YtsXIb1kBzJjSRYR10gKU7XZlGKPLoiRNJG+YzS2IMZhnIUki45Xk38AsxOOP5+u5/P+y6AVmPqK1VK2h8Dn1tpKZNmAbEbjS8iqpRRrIm7PnJxOGO0thlR+LUvHeXcS8A1gSq3GlVN7gtB/BHik1uOoBkHoW6O9g4AAMWiGI6H2z5G+0AOZz0lPeWrpgeO9jyw+h8W2twJ9qcjjXOC3dDaoW4HLe6Ew6l5EjWA1Or6nBUie3WM9fOya0cvV030Oa+07PbXvLDmN5wF7KqV2SHpSKbUTsAcV6P7kDAoOQLqVFC5UGoAtjPbWr82QcnKqTxD6zwJrI171OxDR7XWC0P+opgPrYYLQnwvcSnGkoZWeyXW/BzGA4n6lNuC2HjhepdyMyGHNRoT35wHXIVqrPYorQtwUuBb4FPgIMWC3GtDpQ72c0ziYSPU0KqUOSNj8EHC/UurPSOeBD4HlkGqsrZFwwDI9MM6c/s8EkkNXIbA+eQ/YnAFEEPr/ZeB7FpM4GvGufgcJvyrgzCD0u9sWrYgg9Ocb7W0J+IgnzSIezX2C0O8zVfcuZedCo71LkcrpD52B3VvH/xySd9pSAAAgAElEQVT5XY7urWPWmlrkNPZFlFL7AIfRoas9C4n4XWetvb2ifVqb/O0qpUKK7fFykjettbYvVa71CZyye5/pc9nbGO2dAvyM4q4xc4AdgtD/S++PKidn8BC2NBngGESb7U7gWt3Y3CM5dUZ7SyFybG8GoT+/J44RO94qiBPkzcHcMrGv0dvzXnS8DY7suij4n1f8EBiYc7JSSiEe7u8idls78Ani1KtDbLvbrbXfy7rvUjmNZVUB5eSUyfXAT5GqvegiXYgUDTxdozH1C5wsxwRgXUTf65l8YszJQtjSdCoSDo28/RsDh4YtTRN0Y3PVNQ2dp6/XvH1B6BflcIUtTfVIDvWHurE514odROSeRn4AfA/xKv4EeMJa266UqkMiw78A9lFKPWWtzdRFLNXTmFNdBrunEcDlLl6HhKMt8CBwWBD6n9R0YH0YV0AUIAajQr63mcA2Qej3Ox3DnN4nbGlaBtFPHR57ai5wom5svqb3R9VzhC1NGpH4Od5takdy7S/Ujc35hNeL1MrTuOHhXXsa/3H1gPY0Po94Fde11hYtCpVSDcArwGfW2m9k2XdFvadzcirB9cXdxHUpaOuNsNUAYBqwAZ0n/K8hengH1WJAOf2OzZCCkbjROBLYFZG+GkicghiMhfqNP0Oqu6+uyYhyepXc08g6SOvCxCiCtXaeUuoexCOZiSzV0zk5VSEI/Tm5wVg2+1E82Q8H9umFbhI5A4PPSM5Hb0eKGQcMYUuTAn5Ecj/zeCu3nIFKXj1t6boGpaL5I5OnUSk1EumxuD1SBRafzEAKYdL6yebkVBWjvSHA1xGx2hkDMNcvSbwY8ihBTvk8gxiOI+nsKFgAXFGTEWXE9Zg+CqkErUN6TF8ahH68kGcIIu2VRGPPjRCM9oYhsnObA28Ct+SpN7VB5Wl3ryESiaeVCE/vDryadcdlexqVUksAzyHaY5sgHQ+WRCR3VnWPYVn2mZPTHYz2tkckNp4AXgBm9ESP2xrzMOIRKiQEHhuABnJOD6Abm0PAIIbMHKSn91zgaN3Y/Pdajq0cCnpMn4ekZqyNhJunx3tM68bmRcBbKbtKbDxhtDfUaG9Po73TjfY8Z/xlHePiwIuIHuIxSE7lG0Z7aS0Ec3qS3NN4PbAy8KRSahul1BAApVSdUmoyMB1Yxb0uE1m8FacjcfJDkT6I7cCvELX5bwG/QW5E22cdBIBSakVEAHUKsDTSTuweYKq19vMy3j8SsZx3AjYCVkIm15mI0Otl1tqiCroocTaF56y1EzJ+lByH0d7myDmyPlLufwHw62oYO05i4//oHIYah0wkKwehv6i7x+gjHIdUTo9APEWtiDjwUbUcVE73MNrbGalgXBN4Fzi9J7QMI3Rj8+thS1MTkh87Gni+UG7HaE8jhuUuSO7fzUHov95T48nIt0jvMb0DcH/s9ScAt1Pcz/zk+I6N9pYF/or0gR6JzGEXGu1tGoR+li42pyK/ZRR9i459q9He2vkCr3fJcxq5Crlm9kW6bYVKqc+ApRDHngL+kLVyGrIZjbsCT0YNrkUGSGLRwLNKqR2BfyF5Iz/LMgil1BpICGUM0vZoBvBNJJl5ilJqorX20y52swXwOyQMMx0xOJd04/4l4qrdxlqblEv3DskNwf+b5XPkdOBW2A/TcfMci3gKlkUWIN3lEIrPX+WOtx3wQBWOUXOC0H/baG8csD+yGPonMqF/UduR5VSKMxjvoOPaGAfcYLQ3LAj93/XUcV3l8D8SxlOHLMC2Rvo2LwJOMtr7fhD6t/bUeDKwGek9pjcnZjTqxuY/hi1NOyNOiHFIlejpurH52YR9XIp4ZKL9L4bIgv0GESgvl31ITtdaBVge+F+GfeV0k7yNoLXA95RS9yNz5YaIwfglcg+43lpbUdekLEbjSnRuAB9ScJFYaz9SSj2EXDyZjEbgcsRgPM5ae1m0USl1MXAiIpdwRBf7aEGKBvxCj6JS6mTgceTGczRwUcJ737bWnpVxzIOasKVpFUTv6TPgkQQdtLMoFvIeAfzQaO+8hFykrKxAcc9ZkHyn5bq57z6Fk9b5Ta3HkVM1fkFxocYIxBPfY0ZjCfYAtqFDw3Goe1xttHdfEPqzazCmQv5Heo/pxIW9bmyejjgSumIPig3SocBuRnsqg4cwLbKhSjyX01PknkYAnGFY1ZaaWfIPWxFDMeJLihOLP0Qm87JxXsbtEJHn38aePhMJF+zvws+pWGv/aa29NR6CttbOpsNQ3CrL2HKKCVuaVNjS9EvEG/xbpNfs/8KWpq/HXroe6RWbK1ZhKAGSnxVHA3l3mQGK0d5KRnu7GO19rdZj6QbjUraPdQUfvc2+JLf4bKNv3DPvJb3H9O97ezAuB3KKy39c1m2+BpkjC2kHXhroPcf7Isp2/RjIKKUeU0r9vCf2ncVofA/xNka8CkxSShXuY3PE45eFye7vI9baTk5lZ/A9jazCu5NbGK302lKeX0IpdYhS6lSl1NFKqTyPMZ2dEa9vPRIeWhzJQX3AiepGvEryeq8OeL8K4/g/JF+1sDJsLvD7IPSbq7D/nD6E0V6d0d71QDNSOfuc0d4zRntL1HholfBuyvZPapSLO49038yC3hxIEk6ea0ukInQeYpy9BWxbhR7Td1PsCVwE3JfkZXRpNx8g6QXXAu8Z7Z0EXAI8idyD5iM9fluQyFu3MdrTRnuruvaMOV2RF8JMQObaqpMlPP0EsJdSSrl4+R3Ar4EHlVJ/RFakE8gu4bCW+5s20b+OeCKbgD9n3HfEIe7vn1KejzqVfIVS6iVgf2vtv9J2qpQ6C/GGDiaOoNgroZD80Y2RKmaQfKJJFCejXxWEfpKHMBNB6C8y2psEHIl4SuYBV1IDz8NAw2hvBJJicgBy47kDOLPGeZTHAnsji5V6t21jpPpvz1oNqkJOR8ZdeG3MRVI6UnFeyC2Qz/9UFcPG1yNh2njIvB1J7ak5Qei/CqxrtLcqck5Wq8f0CUihzbJ0FMJ8hlRAd8LJez2ELJILORv4N3AhIh6+vNvHpxR/p5kx2tvF7XdxoM5o71Fg/yD0uywQHawMdE9iGbxOZydf1chiNN6E5JSsiHgdr0QSp3dHjDoQr2DWIofR7m9aS7Roe0UeBaXUMUhF9j9JLi+/GLgLMVrnA+ORXo3fAR5TSm1grc2TmDtISxMIKchhDEL/r0Z7eyCJ5uOBL5BK6nOrNRCXF3kRyXmqORXg5E3+jFTZRsbZEYAx2lu/hlXpx1I8AQ8DdjLaG1WNhUhvEYT+HUZ7w4HzkQKxTxCDMXXBbbT3LaTgI8rrG2K0d0QQ+rdUYTyPGe1diuSPt9ORhrRrEPp9qmdzEPpvV3l/HzmZrl2RauwZwL0pn3tLkotdGpDCu9nI79OC/K4LgKFGe68BOwWhn1lI3bVejVeCG0SCqJyczUGJCge91XgtMFUptbK1Ni2yURFlG43W2hcRr070/zakInljRGrgbeCFeIi5liil9kTCBi3At621RROetfak2Ka/AZ5S6k7g24hMw4k9PdZ+xG2ITmeSt/H5wg1B6D8CrG20VxeEflxrMCcFZ7hthFR1vhiE/ju9ePgtES28+oJt0WJxN+DOXhxLIYuVeK6B5PzWPksQ+jcDNztNwEWlvGZGe/VIlCS+cL7KaO9vQei/Fnt9lgKOaDynGu1djRgks4D7g9Cfm2Uf1cZobxnEmBsCPBCEfo8s3l3U4gWkWPJYYAujvUuC0H8z9tJRKbtQ7hE5QFZzf6NraD3kuqnEyPshxYbqMGBjo721gtCfWcE+Bz6D3mbkj8i1/LRS6gIkAthCwjeT1ajsdlcJa+3fge4IxEaexNEpz0fbM4XGlFK7Iyu0j4DJ1tr4DaArrkSMxklpL3AV12eVOZ6BchrfiIQt16NDnqMNOEQ3Nie2BswNxvJxifUPI+kY7cAwo73fA98PQr83FmQbk1yVvhiyWKiV0fgnJA0hfs96F/HU9UvK9OTtQHL++VDgYODHTmfxJCRKspTR3kzgeLdw64TR3oqI/uc3EcHrS4LQf9N58fpEH2qjvb2Qe02IGGSXGu39OAj9y0q+sbJjfQ2RfBuOnPsTgION9rYKQr9wbnuS9A5NpRgKbGK0t1IQ+u+ljGEZxMj8X8zgX5Pk3LSFyEIuNxoTGOySO4iQf9RK8NISr7NktAMrMhqVUkMRVf7RiNH3WpIXr0yik74p5fmo0rDs4gallIfktrUAW1trKxGp/dj9LVm1PdjQjc0LwpamLZEcqJ2QivnrdGNzXnxSHW5BPH2Fk9M+SLeJuLpAT/AWyfImc4E3euH4aZyGpJlEOnqL3OOw3hJONtobBUxDNDOHA48Bx/SCCPbiJBuNQ5BcYpAmCyfQEcYcD9xttLd9EPpfqQkY7a0NPIt8h8MQ79rBRntbB6H/An0At3C6ic7eboALjPYe6QHv2q+RBXCk9hBJDv2WggLMIPQ/d0Uvv0R+/zrK6/ELcq4uhaR2fYXR3grIXDUBMZDfN9o7IAj9p91LHkMWckn9518q8/MNPgaKi6ZybqaHvoWsvaeXRjTGvkvnC3q+Uur3wCnW2qyr/unu73ZKKV0Y3lZKLQZMRAookoRZk8b4PeSG8z8q8zBGRDeLSt8/YNGNzW2A7x45VcJob0lETSDuzRiBhM16w2i8HwlPjqDDw2ERQ/L2Xjh+IkHov2e0tw6SXzkJyT27rJe7ljwIfIOOe9+2SBX3uCD0u2o+0B0eI/lePQe4z2ivgc4GY8QIYCqiwRhxCWJ4xw2kKxHjpC+wO8WtM0HGuQ/ymTrhilR+imjxjkLyck8OQv8/ZRxvIsmG3zeN9nShhz8I/SuM9p5DemAvhcjOTaTruXQIsT6/zjs8HQlnR+9fHQiM9pqC0P8vYtD+AFkcRK+ZC1yR97VOZ8DE9SrEWntQT+27bKNRKbUcUuiyOuJdfB7x5DUiSfOHApNd95ayE36ttW8opR5BimmOBgrDD1MRT99V1tqv8muUUuPde2fExnggUuzyDmIwlswFU0qtR4KX1G2PCjZqIbab0wdw1aqHAgciXoBrkW4sPRVuH0FnLdRCSuX0VY0g9Bca7U1EVqqbus3/BA6stcizmyTPqcWxjfY2QoyqwsWydv8/DBHm7hGcwTwNyW8bgRg4c5H2dw8iv1OavMbasf9PItlA2tBob2gfab85lGTPqia5EAXkfN2NDsN5F2CS0d46ZbQDnEtySkaiFFEQ+i/i2nga7a2MRAFGubG1k/xbaCQd4OmCbZOQ+TM+Dzcg95opQeh/bLS3IaLSMQVp8Xix+7w5adhBbjX2IFk8jechBuMlwFnW2lnRE0qpxRED73jE2Dos4ziOQnJKfq2U2gbR4/oW4nVpRkJThUSJ31/d/FwT7uuRi3M6cHDU6rCAL6y1lxT8/4fALkqpp5CwwQIkrDMFufCvocpq6jn9A+cFeAiZkKOJaH0kJJ+lvVgW3kfC/avEti9CqiV7BVd4s6XR3uKAzlsWAmJ8JS0WGpCipR4lCP0zjPamI/fWkYgMko+ESo8g2ZiyiBRMIXMoDvuC3Pv6Su7x/SQrIsxH9Fk74WR49qDYoG9AHBFddSi7Ail2LOxgNQ+4tqvUhyD033U5kcchsnOfIqoiSZX+x9DZaFyZdCN4W6O9xYLQn+0KgA5PepHR3kgkKjYHeKGX8p77PHlOY8+RxWjcGXjKWvvD+BPOgDxRKbUJssLLhPM2boLoXU0BdkQEVC8Fplpry9GjWoWO1ekhKa95BzF6I+5B8oXWQy70euSifwi4xlrbaxN1Tp9jG2ThUnjzHwnsYLS3SRD6f6v2AYPQt0Z7ByOTZhQ2bEU8+0UhuZ4mCP1ZXb9q0PAayR6keYinqccJQn86Hek8GO3tBnyfZCMQZGxnxLZdDvyIzgbSfODGvmJwOEPsdCRPM/I6zgeuTrnu1kWM3vj3UE+Ht7wUU4E1EE/lAsSQewQpKipnvC3AqQBGe9uSXCWtKO6g9jzpc/BCJIL3VNpxjfb2R9IKFiHf0edGezsGoR9fKAw6Bmt4Wil1JFJrcmGU6qeUOh5x6MV5wlp7cNZjZDEaF6Pr9mxPUeGq21r7HlIJWM5ri1yI1tobkWq7LMe8BzEcc3LibEWyxMYQ91zVjUYQw8Bpsx2FFIdNB67LvX09j5M6mgR8D5nkbwWeCELfBqH/otHei0hOY+QdChFj5rqk/fUCSUL7Ec3AEUHo/zW2/RykuHAPOgqeHkOiLn2GIPQvMtp7GMlhHAbcGYT+8ykvf4Pk8PJC4F8ARnt7Ix7H5RFj7ZQg9P/hjrUQ2MeFmscDrweh/1aFQ38hZSytxOaaIPRnGO19QHrr3dT2g0Z76yEGY+GidhTwqNHeioNesWIQhqeVUhsBvwHOj0kfLgGsmvCWVZRSl1pr/5nlOFmMxhmIYGkpxpJLAOQMDD5EPDUNse0L3XM9hkve71OT+CDhV0j4N5qI90VSXo5z/98BCQfHq6drVZCQ1m1kFlJVXuSlcjmL33UG0jqIgVTLqvhUgtB/hTKaRTjj669IJXiht3EhcJnR3k+QKFZkzG0HbG60t1kQ+i8X7Odd0ls8ljvmL432TkHSuRqQxcc8t9+kxcX+iJxUoaHZBrzSRZX44RQbpwo5JyYDj1b0AQYIg9TTuC9yzl+S8JxFvPaRw21JJCVvPyRnvWyyGI2XApcrpS6x1r4cf1IptQGwFwUC4Dm1x2ivDqm+OxK5of4BuDAI/bQOPDnC70nuXtNGQl7VQMRpx12E6JWCaDSe1MOVwjXBeW4Op/MiYSRwqNHedUHov+S6zhwBHFGJgHYPcBtSnJPkbUzzygHVMZD6GLshXpZ96FAfGImkesSLgRTyO5+NVGpXlSD0LzXaewnJYRyD9Le+JqlrkYssHIMUt4Ru7C8hnuBSjCF9/s77U9f6yqwNWwB/TVOwiXkfP1FKPUoFgvOpRqNSKi5q/RYQAM8rpW5GhE4/BJZDukjsj+QCvp11EDk9yq1InmnklTgJ2NNob8Mg9BPFuHOkUtdobyfEyI4qVr8Adq91p4zewFWOP4OENaJJ+LvABKO9rwWh31arsfUQO5J8PxwG7Gi0twZSST8E0dK8jdoXjtyA3HcLhfYXAQcFob+glgNzEjgrAJ/1RtW9M8gOMtpbiKQXRPe7uMEYoRGx+p4az+OU2bc7CP1rjPZ+B3wd+LRMz+99yDkbXzAMQ+bmQU0tPI1KqRXpqMtYGqnLuIcy6zKUUiORRcxOSJrfSshCYiZyv7nMWluqGcA45N5UtGuSFRPepryc306U8jQ+TrK9rpAQzqGxbSCrvV1Jl3/I6UWM9tZFfo9C78lwpJPAXuSyDSUJQv9Jo73lkYT0duDlPuBd6i12QRL3CzUjhyI5YTsB99ZiUD1IK+JFjmtktiHX0NfpmKAnAnsZ7e1Wy/MhCP0FRntbIhPNjogE2vVlahP2GEZ7ByGes2FAndHebcBRWRaprjf3Scg8U4d4/s8vZYAa7S2NdKtKq0iOU2neYtUJQn8eXXiHY/wB0W79GmIgW+QcnlaGxNDAp713L0ul1BrIInsMcm+cgUgsHQ9McVKEXUVotkAk/j5DctnvQcLIuyJpMXsqpbax1qZdR4sh/c/j3EBBAV0BX1CBlFspo/FsBquTdwDghKL3Ivk3HIUUc5Q0Go32xiKSFVG7sct6uQ9yzXEVpb1SHdsbGO1tAuyJeKTuCEL/1ZSXfo3kQqCRiAE10IxGH2lckMT6FIetJyPXUNLNuNdwHt87qV17x04Y7U1BROgL8y33QQy/A8vch0KiVhPo+N5PBHYy2tu4hJd7VTqqn7vCItXZ/RKnp7olYiTvhSgsXBmEflDbkfUNauBpvBwxGI+z1n6lNa2Uuhg5d89FUltK0YLkGPqFHkWl1MmIE28zZD5OkqMCMRiLUhOcXnXSvL0UolGaiVSj0fVVzulnOH3BaUj1bTvJyfIL6GKVbbS3FtKFpwG5CW8J/CChH2tOP8Fo75d05LaGwI+M9k4LQv9XCS9vRrTf4ivRufTRYjfnnWqrpHI0CP0PjPb2Q8I7bUj0pA7RQ/xuwltGAoYaG419kNMovuc0IJ7Z48rMpZ6ILFQLDfV6RE1gX5JDcCD3tKTK5STuT+rL3dcw2tsCkQQaj2hunlFQEb8AWcyvgFyrMxJ3Mhjpxepp52XcDgn3xrt2nYnkSu+vlDqpsElJHFfFXFSUYq2drZS6CEk124p0o/Ft5Lopl29SQTphkup+Tv/maGRFU0+6HEcbUhVail8hGpbRqn0Y4nm6ogpjxGhvuNHetkZ727jJPqcHCFua6sKWpuX3X3XXiYjBOAK57ocgk/J5RnsrJbz1bsR7UWiAtSEhjT7lZTTa29Bo73kkPDfXaO8mJ0yelaeRiuIo/WYs8ATilY2zANF0zelMXJg+og1Ytsx9fIPiNAGQe9r1RnsHJL0pCP3PkFBca+wpiyx2Fri/zyLGZ5/GaG97pLJ6MnIuboNI6kx23tjrkSrpSNNyptGeV6vx9iWU7fpRRSa7v4/Eik2w1s5G7isjKOhjXgHRPahULvkTwEZKqS6Po5TaFCmiy7zorchoVEptrpQ6Vin1M6XUcUqpzSvZT06PcDLpUhytiJt6B9dloBRbkXx+bOKKJCrG3Qw/Au5CKpE/NNoz3dlnTjFhS9N+SMjjP5N2/uJxlI3LB4F4HHeOb3SFFBOQMGG7ezwETHC6dn0Co70VkJvlJnS0mdsbeCDDPjY02nsFuTaakTyk5524+d0kp3iE1KBblNHesi5tpK/yN9K/r3KrtaPuXEkMAa402ls95fljgfMRg74dyRPcAvEW/wTJx92snxSzXUrne3kkqXMxUmzhIY6B6LxvAG402uuVlqN9GlvGw6GUshkeZyUcbS33tzllNK+7v03d+ERRw5I/lXjNFcgnuy1qtZyEUmotJEe4HdH6zEQWyR2UUhsjoYHoS1JukCilZgIHWGt7RPQ4p2yWTtnejnQ4+XeZyfutFGsUguhAVVw1arQ3BjEW417Qe4z2Vh6Ici5xXNuxgxHR1XuBB6otxhu2NG0HXIWbdIYOt2gNYfFRLMmeNNzCYhcn20QfFQw+CvGCF1YHDkd6Ka8fhP5Lpd7siiceR8Lw0T4mAE8Z7a0ehP4so70dkKT0KPRpgX2D0H+/eh+jNK5V3u9xzROM9t4A9nd9kHsVlwKzCvCl8+5F24cg3ot4paYFfpZhsfFHxCM4KmFfIGkD3yWhD7k7R89Jeq4/4b7jNCPja4inNCmS1AZsiyx20vY9ETgFqbZ9Bji31sVT1Ub1biHMaPc3LfUi2r5EJTtXSh2DLBL+SYkIobX2daXUz5GQ+D+UUj7iSYwcRMsj3urvIPfIs6y1ryfurARlexqVUmsCf0ZyK55G3OFHur9Pu+2BUmpc1kHkVJVnSF7pvxmE/isZqj2vRERpC5kP3NLNdmN7kX7eeUZ7WxrtnWq0d8hAXDEb7R2CeD+OQ1aPtwL3R4ZZFfa/rtHePd9eZ937jzTjRjz1gNzPttr9C4YMTfzpNSXCzc6j82PgDKO9Hu+xXAFfJ7nwoR2ZFLtif2TxXGic1CE3+B0AgtB/GgkP7oRUMo4JQv+hbow5E86z/xSSgzTcPdYBpjstzV7DtS78AHgFeN9o7z6jvWgy3Bmp9owznwyC+M7LvTnpnsmhJBdpDRjcPTZNpuVj5PxOu5enLu6M9vZAWiTuiBil+wMvGu2lSRP1S5S1XT76A0qpPRGx7hbg29baxAV+hLV2KpIDW4cU1VyLRIgeQsTlv+eeO8tae3YlY8riafwZshrf21rrx547Syn1HeB2JL+irCq5nB7hZMSIb0BOjqjV2VEZ93M24lHemY52Y38BTujm+JYgOVl9GNIFZSwy9nnARUZ729TCm9JdjPaiz3M4MsnfhYSVfkNnD+4oZILcE6ng7c4x10bytUbM+WKInvPFEKYdtxKffDCUPQ77hIN/+gHXnz+WtoVqvrWqHTk/Dg5C/+OU/R0KXOZeVwecbLR3dRD6J3ZnnFXmWcSzEveKD8W1kOuCNUhO5xhCQX6eq9jtqo1qTzEF8WbEFxZDkEk/qZCp6hjtbYx4Owu/r+0Rr9ZkRBMx6btsIF0vMZEg9N8w2tsGMU7jPaVbEZ3Cgc6FSO/wwu90LhJ+/zcd4elCNCndYFwe5G9i+6tz+zifHhA6rxkZbMKktsQZiTyJo1Oej7ZnagWrlNodsak+AiZba98s533W2qlOS/sQpOI66nnegtgGN5a7rySyGI3bAncnGIzRQO9USt3rXpdTI4LQf9l5hH6KeCZeA36R1fByoSTPeZrWBZq7aGtV9q7d2OI3uxARM40miMiTcKfR3hrV0MMr6C3sISHZW3rQIL0LCQVExswPCo4bN3BGIXl43TIagbPoKHQBYMG8Om66sJGdD/iUPQ//hIk7fjnnsEnjT104X80D7i1hMI5BJpjCCXsEcLjR3h8SehrXiqsR43wYHUbVPODRMs/XZ4CDKPZchWTTzetJVib5Xj0CWK0Xx/FDig24YcC3jPbWRKp3WymuuJ9NBZW9znCchug11iPe4FbkOik6/8KWpiWQRel7urG5L6ZSfIVbVK4OfILcE9YC3gtC/4OCl01DihFPoMMMmoZclyDpJ0ci13tU8b9XEPrxQqCIZUnuFqOBKX2ky1F16F1PYnSfSUsniCIeaTmPRSilPGSB1gJsnTWMbK19C3H0VZ0sRuMydH3hzyAhqT6ndwlC/3U6i693Z19vAhWvShJ4HskP250OwzGqbEy6oY1BLsZUA8BorwHQpZLbncF4JR3dIixiAJ2LhGvqgL9Xo9OJ0d4GwNZ0Ng6Hkb4StYhkRnfZlITQvw3ho/8OZYXVF7Yut+Ki0x5oveuyhPfG2ZHkSr16JMWgTxiNrnPPNxEZCoMYjFdRvgbfq+499XTcD+chxuQL1b9X9ZIAACAASURBVB2tELY0DUeMhI91Y/MHXb3ejSMpJWQOvfs7rEFyaslCpGHA/YhXpJ6O6uc2ZOxrGe01BaFf9sQJEIT+GUZ7f0I8qkMRCaRHC42bsKVpceBG5JxtB+aELU1H6sbmPtnu03nwL0K+ywb3dw4wzGjvQSRXtdWFqE8z2jsH6bzWEhNIP8lo71rEEz0H+L8ucsJLdeYZhnx/ZReQ9WV6WacxqkDeTimlCyuolVKLIRJSrUhUpEuUUt8DbkJyEcv2MPYWWYzGj5E8mlKMR1ZOOTmJBKFvnWTGbkgag0UukDNJ75maGD5wUjHX4SQPjPaeRcKtSUndmyIGY2SoRpWI5wKnIhPbAqO9vYPQf6yCj1bIJiQHSBpIrgqdh+SedJe3EW9tJ9rbFIsv1f4y8HPd2JwqAh3zNKR5amyJ52qCW9h01au3CKO9MxCv91Bk4rZIN4aLgYuSvC7unNsPOVcfBv6cxTsTtjQdjnR3ABgatjQ9AeyjG5tLha5eQMJKW9CxEFmAVBnfVe6xq8BjSHekeA7pcKRb0iKjvc2QlIbd6cgVHYXoN/7EaO/HQej/hgwEof8MYsR3wmhvPPC9qx4bvv/KTQuW1/orQ3UEcEvY0vTf7Zdf/wVkAbc/8hv/Hng45bfdFrgAMejfRYp3qvr9OpWIX1Mcxo8konZEPIlRtWzULebtpP0Fof8aEk3qkiD05xntPY4YmXEUcj8eEEZjb3oarbVvKKUeQbQaj0bO/4ipyJxzVaFGY1TdbK3t5IhTSh2IFLu8gxiMfa6ZRhaj8THgu0qpfay1t8efVEp9GzEEbq3W4HLKw2hvApITtxC4LQj9f/fw8YYhRt4RyAUxHTi+XC+CW0HfTUGFn9HeKsB5FN9MPybBy+iKA6ICheg83gx4xlW9xj13uyfsOyIyJBcD7nPv/6icz5LC2yR7huYhHpF9Ec+mQsZ+XhD61ciXOwf5Tgs/57xFC/Vto8e/lup5dtpuFwKrGu21IGFun+R2oAuQibdf4yrYf0pxqsBIJG2hyLg32tsF8XRpxDNzBPC40d7u5VSWhy1N2yD5h4W/z2SkJdx2ae9zC61dkPDwYe7YtyHnTW/KH10KfB85L6Jrbi7SKeozN9aPgL2N9jZEckCjz1qHGOfTjPbuCUL/v90ZiNHeEcDFY1ZcOGTsKguH6mL/Zz2S3/0+8p1F/eP3RPLEDovtzyAFYdH5sDZws9FeQxD6v+vOWGP8hPT7UDTufY32srZdXBW5x22DVFfPRoSmr4kVLl7hXpMkm9bd3L4+Qy9XT4PUDDwD/FoptQ1iyH8Lub6bkUVTIZGh/9V3rpSajBiMGplTD1aq6Cf5wlp7SdVHn4EsRuPZOKNQKXU08qE+QJIst0KS+WfTz6UO+htGe5chq9Koy8cPjfZODUK/J0+sO5AE+OgGux3wvNHe2rGcnCxcgVSmfhOZuFsRj5aX4snZBclfKjyHo3DPXhRLE8xz++vqnNeInEd3vr/HkDBdQ+x4bcjK84fIan8xxFOVSbrFaO9biIG9AbIinQb4Qeg/Ek2myHdYhxiRqUVQRnu7I4ZsNJE1uvfXIS3KbkY8cJEn7oL+WJiUwJ4kT5wWuc918oYZ7dUjfWHjRUyTkfOtHM3GH1NsMAwDtghbmlbQjc2p2qnOOPwFKa0OXfrFN5Hq5WeD0M+UdF8OQeh/aLS3L7KgKEzuT3IURLIecULk2q24SYDLt/0VUL/M2EUsWqQY3lB0i9DzW9W6SMV74Xc+EjHKrgpCvzD94AKKFxAjgAuN9m6tYq5fkpB+HIXcG8oyGo32zgZ+hHzfhVbGRUiE5SCAsKWp4ZYXhtoDJ6zdFrar+LnfDnzTaO99pMvMGUHo95Wc3uz0ss3ovI2bIHbSFMRj/AGy0JpqrU2rhC9kFTrSPw5Jec07dG9u6jZlG43W2v8opbZFJpGJ7mHpOElnAgdWovuTUxnOw3gIHTfFqNPH+UZ7fhkC3pUcc006G4zRcesR46Si5FvXS3VbZBKeiCQA/6FE27HVKU7KB5nI10jY/nvkxtrVOd+A5O9WTBD6odHeJMTIiK6TN4EDgtCPpEfuSXu/8xocjaR7PIV4Cz53z30LMUqj33wp5LNdb7R3AXLTWgoxKucjxtFyRntetI8YSd7dEYhxOwZ40u2jHvhjEPpvlPk19HVKTStJz01Mee1IJPRZjtG4Qsr2hUjOWkXXq9HeGkhe7hhk8h/uFo5Vrap2EliRwRjd95cHnjXaexKJClzlwslpkjCW0l0tymH7aB/vzKxn6LDEn3Lhv18Y+TGwZsJzIxC5or8CpznjKE0MeQxyT2h1mp6HIw6S14DfBqFfsh1rAo8j965S96GPKDPNy0ibwahQKM5IpH3jOQ+//9LawO/HrLCo/WfXvG3PP2oVFi1QbdaqaBx1SMEVyMJxC6O9HYLQf7KccfQ1aiGpY619D9HfLee1RS5Ea+2NyAK+T5NJ3Nta+wKwtlJqM0RkdjRSbv4Pa+3TPTC+nNJEk3mcEFlhX90Dx1wHmeTiq/LhSPuvinGr+cfcA6O9NYz2rkPCKV8iq7ZLXbjlJSRUGl8xzyahf2cQ+jON9k5AQjalzvs5VKGfsPMebm20tyQwrMBY/ApnHK6CfLZXneE8EcmVG4p4obZBvMcbu0XABSSHt6Jw3JpIfl/ha7ZAQnLbJ7xv1ZSPsCRQ78KNmbsG9APuRASO4+eCImbQO6HlSaS35SypnVZAgFRSxiWn6igzLy2O8zD+CfkdC4O05xjtvRiE/hOV7DeFvZDzsnDCU8j3sgNy3/mO0d6pSDTiZIq/3zq6L5ezEGeQzp1Vx51XLMueh39Mw8ivDIU2YM7N0xofQu5JSRJfI5FrazOjve2Q/NCk6tdZwDyXy/p3ZFHagKiE/MBob3tnJJfLecj3OIrk+9BC4KgMns2DSG7CENG20przt0OiESMANpsyi5uefY0/37nEkJumjWXRgqLYfpTvfRHdvKfXjH6iw9gfKdtoVEpNAmZZa/9prU1MTM7pdRYiN+r4VR9S/kSWlddJvgkvQAy5qmC0tzzSkmxx5PMtgaQ+jEfka/6M5IqsS0cYbCESEkj04gWhf7WrtE3L71uI5El2txCmkC+APY32jkImitsRHbU7kIT7KOzb6kLLP6OzcdKATNTnIKvYDUocaySwD8W5iMOASUZ7yyeEwt9AcqA6MWJU+8Ibn32tKoLjfZEg9F8z2jsT8cxGna0scFyCh/5aZKJP+j7mIsVY5TANKaIZTcdiZy7wU93YHBfSL5eNEM9Q/B7QAByDtFjEaK8REZTfEokKXRyE/ivRi4321kI+x8bIwulq4OxYbucKlM7H0+75XyAeyJ/Rka4UIt/z95MWUBl5kILPe/O0Rt77Tz3eUR+FK49b8MnQYfYB4KwZL45sRXQO04iMo2nIIuJkOt/b5iLdUqzR3vmIBz86B4a5x7XAOkZ6nY8H/lsq3SQI/XecusKdJHfPaUPubeUSSRGlsstBn6xD7PxYakwbOx/0qX3n9XoV3JHWRIz1Moyjb9Gd9hM5JcnSe3o64prP6TvcRrJxmHk1H7Y0lXUuuGq9v9A538YiBteVzvNREqO9BqO9U4z2XjPa+7fR3kmuuKaQ44lpDrr/H2i0N9Z5G7cCLkdCOV8iVaZXkC5tAyILkiRvEyIyLTtXWavsEqQ6fGsk5+wiJGdobTo+W+StuZpk3b0hwB5Ge9Mp7VWA9Gt6EaLTFucUsJ0MluEN7Rx2+vtDRy/V3mtdT9Iw2lNGe/XlnFdZCUJ/GrLoOAUpUGgKQr9TFbvR3jqIIZ7kZVyIpOv8sZzj6cbm94H1EUmgmUio0tONzZmqiWMsQXI1u8L93ns37r7GsPrwzSFDw1OAzZS2ByllX3AeNoz2vo14OiciRsgySMgzrhv6LGJIdYVy+zsK8eyfihhkqweh3+1CySD0ZyNGfCswB1Tr9LuXnH+UWeu04SvPXE43Nh+iG5vfDUL/E/e6uYjHMI0JSM/qaAEHcj85C8nvBfGkJi0a1nRpIS1IisAbRnv3GO2leaUJQv8dOqd2FdIGbFhirHFKSS61AR/uuN+nn1lbnF9aN8SqxUaXrN/qTjFgTRkoHWH6IlnC059Q3FYup0YY7S2HeNVORdT8Q/eoA/brQq8L+MpQ/BEyYS4ZtjQ1A8frxuZSTdFBwp8XI4USw4D/IB7BN4DPnPbhJSmyFhpZSW9AhwF0NrCD0Z4peM9Ekj2a85EQ+QdB6M822rsS8bZMoiPX9pdGewcEoZ9U5fsvJPcq8hSATCp3B6Ff1SIuF34+nM4pBKWMn3rSc+0WR4zkrpiPnANJ310neYcPX1y3/pBTl9jo2WDx2e/OrG+YO6eOZccuYv8ftbDdXp8PATYMW5o2RCbQHyKekX8AF+nG5h7NbXRG4rGIp2hJ4EOjvZuQJPN1kLZ05yD5nhXPAE6up1Tu31YlnvtDEPqZOi05w/HYLO/pgudJ/q1bcXI8K6654OF/PTuywYZy6tlQKaBeKfsHlw5xG8Xn5XBgW6O98UHoR+fNo8iCZ0NKL16GIzmaIIbj34AtK/md3HmwG1LtPBS4BVGIeNBobwWkeK4BeDAI/ffi7w9C/wF3r5yGCGGnUShIvghZGD9csG0OyZJgQ5Hfs4GO72R7ZGGwnzt2E/BGzAOZlrM4hPT2gUmsVeK5mcCUc3+w6k0//e07auECTV2dZeTi4oazobIvPrkYJN+T5iKh9P5JmLsae4osRuPjiKRJTg0x2tsE8W6sjlzszyI5axshN7v7yjEYHecgIatoVdwE3BW2NE3Rjc1Ppb3JiWj/wIVTd6Vza7GlEY/dEORGHWd7pF9w4aQzApEn2MJo72lEKPg/blv8HB2G0ywz2jsPMWbiq+g64HdGe88hBvFuyILnNcQIiCYvi4Tbz0WKVqrN5mRL+ldIOHsUxbma5XjaWhFph1MRb+uwgu0/LAw1hi1Na/7uohVfmn7PkiMWzlcoBcOGW3Y+8BO22+urOStEfq/TkO94KGI47h+2NE3Wjc1/y/DZsnIc8rtE5+ZYRCInYiVk4TKa5POsWnxM8m+4ABEGLxujvSZkkn+1WgVFbuF0EqL9WI94y1qRwqvrw5amse/MWHeNyGAsxFpGIyklaWkICrlWZ7hjha5Y7QQkl64e+V2SqtAjGhAjc0tkDsnK1YhEVXQeTAT2cRJEyyK521sBxzqP3+8SjNNWpBtTGvEvZ6jb75bA50Z730E8pueT7MmPG9D1SG5nO+LpXIAUJ90LHOiuw19TnCfbjhiXr8FXRW/nI9/fe8DUBN3IUl7Ji4A1//rw4hMO32otPv1QfqZ1Nmnl2AveQ6EefHtGw8bI/bceuV+0IQvPC+nPucy5zdhjKFumm1YpNQ54Drl4zu6qcXZOZ5QSjfru9Ll0UhP/ofOquA25oYwrRysuImxpakBWu0k5So/pxuZtSoxjJUTAdEc6BHzjfAEsE4R+uwvxTUOMW0uHkG0hFgkvr0GHVE3U8ziiDTHyJiH5Qw+njD9iFh05gWnMB1YOUtrpdQejve2REF+8rVoai5Bcp70pL3Xkf4gI8bru75lB6P+f0d5YJBwYJfj/Mi5Y/uKdG71yxgGrrbtgfufDKGU5+rz/ssuBn4FMtjNJnpie043NE8r8XJlw3qWPkQVIV8xCzrMeuR85qZ3/Id7OwvO8FVirHL1BIx2L7kSUARYiBvjDwN5JepCx945BPGQbIQVeVybJWhntbYpU3I9BcnpvDEK/NWxpmnzQZuMf/eDt4VlSkSLagG8EoV9UWFZw3GMQAyMqjkvyei5CqpQzGfdOS/N5io2yuYgH/3JkgVVXsH1aEPpTY/sZTpnyNSnMQu51WbRU2yhuGToPqS4/0Y3rFMSTvgD5DP8Ftg9C/12Xez2dzve3VuCEIPSviTYY7T2DyOokcQSSr3xMYTRcacvQYZaFC9SxWHUV0klpWeS7no9EcbrzfX1FNea9So63/fpdi3g8/JI0jeqtsQ0UshiN1yOVmROR0NBLSB5HfAfWWluVFnYDiSoZjT9B8mziFdOzge8Eof9I7PUbIl1QhiGhqiejVXjY0rQq8ArJuVof6Mbm5VPGMBIx3MaQ7qGADhmRJZCQ1iiyi8cudI/C3MZIb3E64g0oNRm20bU3fS4iTF5uMUPZGO0NQYy5Rrr+7BZJNwgRT2s5PBaEfinjvgnxQE1GJoPrgVO/d2LL6o/eueTMD98bppKGNWRoyKGnfbBo852+fG7pxkUT6+oSxx4CQ3Rjc9WTg5yhNpfyDOd5yH1pLpIz+hnwYjXzUl3hwn2I4Rgi59W+8eutxPt/gxRfFV638xBR7J/EXlsXLf5c8dRldHwPi5Df8WLgLSSqUDKUGbY0rXzfDUv/59pzxg5dMC9zXVMILB6E/lynAnA84rX/BEk/ecCNcwnEqz4JCUfH7ymzgcOD0C9qClEKo73jELWA+P3OIvPPuhQvCOcBy7m8x2g/itK+p7T8woi5iD5eVx3RCkkqUAQx/EZF56fR3lJIhfInFJy3RnuPInnQ8XF9Boxxi/F9EYmWtMLEvZCiwR1TxnhxEPonZfhMmamZ0bje6V2+9uGXJRspNxqzkSU8fVDBvxvdIwlLlfoe5xQxjmSJHY1It3yF0d6Pka4tw93zhwAPGe19Dqw2cvF1n7jrtX8nCM5jkby/NPZGPGddzUCzkTyg8yijwi+FYcjYF9CxYo/+mjL2We75PcTpKo5BEsvnAUOrUOXZjniJbkAMjjgWMQJmIwLJN1Fmf1Jk8rkw7UmX7/U84tWNWrn9GNjv9svGfBKGJBqMAG2LNNefP5arzlp++btee0WNGp04387tCYPRsQBZmI4t47XtSPjy58gCow5430mhvF3OwVwRVhik9B0PQv+fRjoWrY+cky+mvTZh3wqpeo9ftw2It+wn7jXHINXGyxrtvYOcDz+ls+Ex1D1+hvz+Vxjt7ROE/ldFb26hsrMb6xuw/l0PvvfSg+801+/04O+WHhK2Q4ZLcS4iG/Uk8CJyz48+x6ZGe+cGoX8+HYVcLyGGbaERFiLXU6ouaQk+Jz01oFRY/OsUqHu46ueFJBtX0PUXUo/ce9NYgPxOheNJW/CMcPtqdmP7jILcSaO9A5G0jDRNzxHA0q4a/lrSP9MCROJpzxLjztRUoF+RF7r0GFmMxqSqzpze5S+I0TYqtl0hoV3gq/DxVDpPVCORLg3tQN3cWUMm3n7Zsov2OfbjVqU6QiDWMj9s58wSLp6vJxw/TqSjtojyvH2lGJLy/hAxuNIS8mchN9QkIzu+/9MQj2jUUQZgkdHem4hkybbI57kRWZ13GbpxEib3I/p5SeP/N3BYEPrPFrxnc5K7aMRpRSadq432ZiK5TnGd1BOQ3zw+IS7f3qaXowsWLdDtwJg/3rQ0exz2CfUjOm7C7W0srBvCVWWMsyLcJP9TpBK+VPoByMJkGvI5o99ujSWWXfRI2/tNv9CaIcADSd1WnCf2WiRXOzTaux/4QRD6HztDbnXknIgKvb6G5M9t6Iyz3yPewtYS41Okn4ORR+5EpBgs+v8qFBuMhWg6rsHbjPZWCEL/C+cNjHKCR+HCtcfuMG7y5Y+8/r9vbD3r0HO+v8rwRQvL9jhGfcZ/gEQN4veTM4z2vkBy59rc64ciOcdj3Wf/N+KVrSTceQ+xzjwF43qXjmKbQhqAy432JsSO+Qek01NX3uskD+F85LsckzIWH7kvrkd5FvnfjPa+WVBgBIDR3v5IyL3UOR8iqT9TSb9XLAK+HUiv6ceQgsX4uEIGsmxe77cRHDRk6QjT5xpnD0LuAE6nc+XvPODxWN7RjqSHY6IZo+HGX4ytGzEyfHqXgz9d24Ys99aMeq46a4XhLz8z6i/g/R2ZjPdEwiczkRVwOefBMDq6qnTHYCxFO6KnaOiYzDTyue9DDMHnSrw/RFbjnyOr+vhEMRyRxVm7YNvpwBSjvZKVoEZ7dUgnl2VIr0z8VcxgnIKkEJQz6TTQode4EjDRaG8vxLM4202WSUVEEeVYDUPg/9s77zg7yqrxf89NQiqEIC0QJIBAUF+6CEGl6KUL6Ou+vKhAkCIoTX1Fikqo+kNEkaJIC4IKrAVslCWILVQBadKJEEIJAUIgfe/5/XGeyU5mZ+7ce/e23T3fz2c+szPztDn73Jkz53mecxh2zXnjWWvCUnbcax5LFwvDhivPPTby+c22WZCMpVqWYqFjDGYZPQjrH3diztrvTCpdwfK3NSu+FLOGEHuNeHxk7zeHnHjhixujXBjyXVB6ZZMTC2s/dWGsjlUxq3L0sTAEs9D9pVjoOABTBKKQb/OxBTdR/OSIjbGIG9sn51QGpXIvbO7tK5jfwjgKPFa0GOrfpPeQbqVzEEvAxcVCxwRMWVwv1sYxwMhnHx118e7rbLFXYYjeXermPHorP1lDqYL9xr5B+sfZUmzleVJ5iSKLKPa8qGY18HLCIp89sJjQUR2KKX/lFq69D5uWE59y8iKV/bYK2Edv3LPCXzCr3dn0VugEs3QXKiwf7H99Dr2tgGnlx1kEXBSCAKxD9u9YsY/G2+lR5pNtiz4IBiTuUqdxVDSnUUTeiykOCtwXwuU4VVCvuR1hDsy3sPkqi7DVhT/osti0UZpDsC/0PIsg2CrLWdhk6rThnuiFopiC+lvsod3qeSDvYHOaxmMv+3cxx9n/ic0L2g6z9qX5J1yGPeyvJt+alax3v+TCkoiw6OEubHiwHNdiFoCDsJfyJKrzm5pEsf9VNzY/Ks3hczX8g1jovPesvZQJGy3ipeeG8/rLK/2oq9R5fKUFBavdDGxBTVIRXIS9kDfAFJ4Hw7lPUH4BUypjV1vGNfc9nhaLeCGwVWHtp54MbToWc0Kd/N8vJXtxVxrvAId1lTpviE4ES/99mEJaznK8jDA3lL79r7op/yGwDHOHtT69rZ6LMavd6phi3I0pTQCf7rJ45j/HfFUm27gUk1Peh+HL2GKzmsIHFi1837GYIncxNj0mL4LOo8C2XaXOxcHN15ukL8BLoxTSP4dZoq8M587DpptE02b6wutdpc7lz6XwG+mmfL9bhi2EubhY6DgCU9iz/EEuxOb4HoF5Ikgra07YLscWWNV9MVmr5jTuMemkvKTc8oSFcfc5jdWRawUSkfOwr5ZIsCoiP1DVrze0ZU4qYQ7MV8KWxe+oPITgcMy5bdYLOu6AehSwP41VGLuBV0HHgmQ6yMXa/QS2AjV1qVxXqfPeMHybpjQOIX3YJo+RmBUvK2rMBeQrjIuxhQzfwuYZlrvPShF6VpunLmKKEVn2spTleSRi8c59ZRhzX1neRfKG/JNshw3fJRWoaEh539i5XaosewUm7zGPUikK8LICwzDFJ1pZ+37S779aRXUM5s/wN5gPyUnYUHOeE3aonxU+z3I8BFPK0+a/Dccsg2tgSvvumGX117FFNj/CfLMm76lAZcrTeMzlTSXxuVegWOjYH5vfGSlUX8FGXPKYBPw9TPkYSmUf0BEFbOX+E9h85JWxj4MLsP5ZLipTpbwGEFwYHY0p7G9Q3mPAUMwH7fXY1IjjsJGQtP//MszQM5F0S/JQ7P8yHvt42rNY6Ni7zoENWkdpYNxGO1L2oSUiB2J+8BT7AQnmZ+yrIvKAqlb9EHDqS/iK7gAOwf5PV2JWnUqVoXWqSAum4ORZNvrCEGDMjnu+xb3Tx7J0SeJZJwr2YRgtCrihWOgYV2bO1LOYFTXZXsEslNU+XQSzzPYiDEsfXkEZy7AX4UNUr4D1hcha/Fns/34WvV3JgL0ks/rEIkzhrYYPVJm+ZoYMU4KxIUmBFZXW+zFFoBplIo3FmJL1PPbiH0X9fhuL6QmV2VfLVtaCCTC5vIhZ3ldwyl8sdOyHPVPS+mk19/lJqlQai4WO1THlKKmsfpbsIfWIocC22KK+z+WkzWJbbEFW9MxL9qFa6QYeLxY6bsHckI3Efm+VWGKHhjaVsAU0czB/ksn7E+yDdP2Ua0lGYSvft6d8hJn+gw9PN4y8znQ41pE/oaofUNX3Y1+iJXyFdMsJQxo3YHN39sTmUF2NzY1bUiZrnFqshg2NSTz2PUtXOfrM2aPHrNrN0GHxqZnKiFG9pmqOAC4oFjrWKRY6Vi4WOt5fLHSsDMvnlV2AvXzTEKp/mRSASaHsJPuRL883MGvtrjRXYQRTGr/RVeq8qavU+WNsbttVKenKzc/qxvpYNTxB9cp5Tdxz+ypI+n90EfCb2PF1mEW1HvO6DsXmxVbiVaAahmGWor7KrpLf+FgspvPiYqHjW8VCRyH4fvwtFgmlr6MLC4uFjk2K1YWD/BTp8hxWRXs2pjan4mAK4jhM4R5JfRRGsHv6NPYuHUXPvVRieY6mMgwN+TejZ+FhxBJsisoEKrN4g8l04ATvUM3fnJrIe2FuDtykqn+OTqjq7djE5HqY6J0aKBY6xgUfbudgQ2Lx4c3RmGWtnGWh3mjY5mFDn7Pow8t4/PpLeP6JEex2wBtsuuWCYDmyudyL3k19Jx8Z6nwLW/wyp1jomIUpi3eHc/Wcr3MScEvKC/DQCvKOxhaEnF3H9lRKAfhesSfOt1KZA+2IErB3mnPpHO7CFlKVdWRdD+a8tBJXn7s2ixYKy5ZCqRuWLWUp8NN4BJsQ1ehDVBnVJYVIsWjElI0C9VdE8xiG+YKdBtxC/e7rQGy+6sww17gSxlO7m5w41cxZbhZ9tRyDKY6RG6S4PBZjxp5qrOjdwJbFQsd2VSr27Ul3KX9zaiKv444jEa828AQ2ydtpMsVCx5nAXGxC+Elkz4erehFBH5CwRcNzE+jDi+7pf43k7CMncsNFa/LYfaPDR2HucyyyGo7BXuTRiuiVsC/oal1+vFvmWgH4ODYsFGdiBeVGq7IrtQDUmxFAsVjo2Bzz07ZfFXlL9KyMrZgw3PljmvQh8+ufrMlxe21MO6XPLwAAH6hJREFU5yVr8utL1+D0L2xwR2Htp3rNAQ7K72XYkP1Apto3ZAFboFXpwpFKGIk9G94L3FW0EHl5pPk2dfJZGVtBXg0jsMWVdwA3ZYyk9B+0lL85NZGnNBZIt9BEq+bqhohMEJErRWS2iCwWkZki8kMRqerBISKrhXwzQzmzQ7mZUTbqVXejCcNF36T1K5cbSnd3gUULhmCL2qKtTwyn+qGlShannJg4fq7CsqM4r61iE8wdR66/xgRDgauKhY4bi4WOfcN82lzCiv/LaGK//c+TI5n2/8Zz+VnrdN87fZU/pbRpw2Kh4/tku5MZSNTDqlVPCsDfghumVIqFjv/FVkw7zUGwZ9Jo7IO4krnZ7YsPTzeMSh4mDZeuiGwE/BMb3rsXcyXwHBa26i4RqWgILaS7K+R7NpRzbyj3nyKyYaPqbhJntLoB/ZhGKGnJqA0/qiJvK1/kS6ndijQEs07eAPyqwqGsc2ndh84Q7FmwnGKh41LMYfdXyY684TSWYViIwF4ULXb6VTR3WN7pYRTmqqf/UtL8zamJSl5cU0WkO75hQdZJng9bLb64LsEm5R+nqvur6kmquiumwG1K5fO/zsGsKOer6sdDOftjCuCaoZ5G1d0MVs9P4jSRvyeOF9OkBR995EL6Pql/OLZQ4awK0m7ex7r6ytWRVTS4ODmSAW6t7yfsm3G+g+YvEnNWpH9b393S2DAqURqlyq0qC0qw9O2GhZ66OHH5NGxu2UEiZX32ISJjsHk472ITueNchEUm2D1ubaxX3U3kmVY3wFmBkxPH2zP4lJFvFAsdac6D4zybc73RrIy5FAH7XTvtwcoZ5/dqaiucNDYtFjrqOae1ubjS2DDKKniqWqhlq7INkTPf21RXnJ2qqvOxyBSjsBdyObbHvo7+EfLFy4l8WsXrq2fdzWLH/CROE/lt4rh/zwOqjSHAmbEV2Wls06zGZDCMHiv9B1vZEGcFshYguWeO1lMAzm91I2qmuzt/c2qiHSZIbxr2T2VcfzrsN2lAOX2qW0SmiohWsuW0vVJ8eLq9SLoOyVxsNcDJi0KTZVFqFlEYQ2hcLHSneh7NOO//o/ag2OoG1IxbGhtGOyiNY8N+Xsb16Hyei59ayqlX3c2inBsYp/m8lTiuNlLKQKGARabI4tpmNSSDhV2lztnh75da2hInQrHwdWlkheh0mktq5Kt+gSuNDaMdlEanco5vdQOcFUjOvRqM0wcWA1cGZ9lZnEj1vgLrSdwX5Zda1gonzqVdpc7pGde+2NSWOFl8vdUNqBlfPd0w2kFpjKx5YzOuR+eTVp16lNOnulV1qqpKJVtO2yuiq9T5M6CrHmUFlmHzivryC6rWaXZa/mWY8tGfPK5e0VXqfCR+oqvU+Ta2gn+wsARz2t3LcXac4Nx7bVpj5ftDV6lz+W+mq9R5B9ZmpzUsAr7QVeo8OitBV6nzTSxWdT2jODmVo8CpXaXOGbkp2xTVUu7m1EY7zB15Muyz5ixuHPZZ8w77Uk696m4aXaXO3YqFjrHYJOWF2HytBdgK8GXYPMwS8L/YIp57sZf7JCxk3B1YmMFru0qdfw8OdtfBXupbY6vMP4wp1POBF4C3Q10fwsJNFbHwa1dgER4ew75KD8Pc0JwZ2rQN8Fqo+wVgq5DvMcyx9CPYsOYHsegP92OLFvYA3gS2xWT/IvBqaNtqwGexyC8LMB+bW4Z2RM6C/xDucyvsxTMCU0qHBZkcH+7tkVDGWti8vNeDLJYBGwDXYEr6heG+52IvvTO7Sp2pT52uUuepxULHN4MMotjOBeCQIOPvhvLXDXU9H+T9L+DhcB87h7ZvhjnhHoIpXKOD/F7H+uwY7P/+IawvfzjI/x5gnyD/+0O6McADQaZgPiWfAT6POfN9NMikhH0svQHcF+rZLbTvQawP3RfuYV5XqbOi0IBdpc45xOZ8BufNO2FTLrrDvb+K+dPcCngZi7CzEPsdPoT9X9cHDg73+W6QzXDMt+rC0N4vYX3mkK5SZ6/FFl2lzi8VCx1fxfw0CrA39n+dgfWXdbAX58+CTHcJ9cwK970h1mcO7Cp1PlksdByPzW99GbM2vxzkuAyLzPFAyDsq1PV34K9YX94C+wC5p1jo+DbmL/atIIvrQr1PYv+/EcBHsd/GPiHNqCC7XbD/50FBzsXQjs2xBYK7hnJexCJ6rYv1x02w/jIZ6wNbYL+zI0IdF2P97WnsmfAB7HewBPtNPxHa9UGs766H/a7Ghrafi62eHx3yPB0+IsrSVer8Q7HQMRx7Vo3CfjfDsTjS64T2dGN9Euw3tib2PFkdi3a0Q5BhCVNC1wt5dgzlSJDdKtizYY1Q1uQgg6XAv+n5PSzB+thW9PSVyKfha6F93VifeS20aVaQ1xzs97gQ+CH2XJmETX06NaR5JLRlJax/PBbaehL2v3sw3MMToV2/x/6/v8T6xCKsT8wO9T+APRv2w34rN2H/wyHYb2tD7Pf0/ZB/YijjN5X+rtsWDxPYMERbPLYf3N48g738NoqvYhaRlbEHnwBrqmrmEFhwufMa9oAYH19BLSIF7ME1MdTxXD3rrvA+FaBeVkfHcRzHaWea/d6L6tt9lUNz09769lWAv5OrpeXD06r6LHAbptB9OXH5dOwL9Zq40iYik0RkUqKcdzDL0Gh6+2k8JpR/a6Qw1lq34ziO4zhtjC+EaRgttzTCcovfDGx44SbM9B4NCz0FTFbVubH0qV8vIeTfDGzI5Q5saHYzzDz/Wijn2USequruwz26pdFxHMcZNLTK0rjb6INz09727s8AfydXS8stjbDc4rctMA1T2L4GbARcAGxfqdIW0u2Azdd6Xyjnw9i8sm2SCmM963Ycx3Ecpw1ogaVRRCaIyJUiMltEFovITBH5oYiMq7Kc1UK+maGc2aHctvAD3BaWxsGAWxodx3GcwUTLLI0jPp+b9rZF5j62Hm1LGbF8Alsctwu2iGnHSgxQKaOl92ELpqLR0h3iU+xaQTusnnYcx3Ecx6kL2vwwgZdgCuNxqnphdFJEzsdckp0NHFVBOedgCuP5qvq1WDnHYaOfl2DeRVqGWxqbhFsaHcdxnMFEqyyNxaEH5KbtWnY90Pe2NdEDzHOYi6SNWmltdEtjk6ljHGrHcRzHcRJECmElVPlOPl1VpybO7RL2t2nCa7iqzheRf2C+brcHsqIgEa6PDOXMj19Q1ZKI3AocGeprmdLYFgthHMdxHMdx+iGbhn1WEJCnwz4riEi9y2kobmlsEgNxWDr+hTYQ768euIzK4/LJx2VUHpdPPoNFRtXem4hMBU7rY7VRuOF5Gdej86s2qZyG4kqj4ziO4ziDjjDUPLXFzehX+PC04ziO4zhObUQWwLEZ16PzbzWpnIbiSqPjOI7jOE5tPBn2WXMNNw77rLmK9S6nobjLHadmBss8mb7gMiqPyycfl1F5XD75uIwaRxNd7jwLTKTFLnfc0ug4juM4jlMDIRTxbZhC9+XE5dOB0cA1cYVRRCaJyKREOe8A14T0UxPlHBPKv7XVEWHc0ujUjH+95uMyKo/LJx+XUXlcPvm4jBpLShjBfwMfxnwqPgVMjocRzHJ6nhJG8F5gM3rCCE4OSmrLcKXRqRl/EOXjMiqPyycfl1F5XD75uIwaj4isB5yBhfl7DzYs/VvMIfibibSZkXJEZDXMDdD+wHhgLnAz8G1VndXIe6gEVxqdmvEHUT4uo/K4fPJxGZXH5ZOPy8ipFz6n0XEcx3Ecx8nFlUbHcRzHcRwnF48I4/SF01vdgH6Ay6g8Lp98XEblcfnk4zJy6oLPaXQcx3Ecx3Fy8eFpx3Ecx3EcJxdXGh3HcRzHcZxcXGl0HMdxHMdxcnGl0XEcx3Ecx8nFlcZBgIh8RkQuFJG/icjbIqIicm1G2vVE5BIRuUdEXhGRxSIyO+Q9VESGpeT5mIhcIyKPishcEVkkIs+LyO9E5ONl2jVSRE4XkSdDntdE5AYR2aye959Ho+WTUsbwICsVkUwP/yKymoj8UERmxuq5UkQm9OV+a6EJfWhKKDNrOyqjrkHVh0RkrIicISIPi8g7oa5HReTSDLm2hXxCWxrdh2bm9CEVkW+l5GsLGTWjD4nImiJybugz88We1/8Uka+LyMoZedpCPk574KunBwEi8hCwBfAOMAuYBPxcVT+fknZnLHbmPcBzwBtYSKQ9gfWAPwO7qeqyWJ6pwBEhzyzgXeC9wL7AGOAsVV3hYS0iw4HpwI7A/ViczfWADmAJsKuq3lOP+8+j0fJJKeP7wJGYbF5S1V5KoPSOQXpfaFcUg3SHZgaub0IfmgJcFfI9lNKEP6jq/Yl6BlUfEpFJwG3AusDtmJyGAROxGLfrqeo7sfRtI5/Qnkb3oROAVdOqBk7BXMx9KN6P2klGTZDPxJB+TeBO7H5HALthz5mHge1VdWEsT9vIx2kTVNW3Ab5hL5SNsYfnzoAC12akXQkopJwfhj2IFPifxLURGWWtC7wKdAPjE9dODmV1xuvDlCIFHktrR3+UTyLdzkAJOCqknZWR7tJw/fuJ88eF87cMsD40JZyfUkWbBk0fAkYBTwFvYi/2ZN6hBCNAO8qnGTIqU+/uIf0Dg7wPXRzOn5Y4PwRTDBU4uF3l41t7bD48PQhQ1T+r6tMafu05aZeoainl/FLgxnC4ceLaooyyXsKsZQVgw+i8iAimNAGcGK9PVW8C/ga8H9gpr731oNHyiRCRVYBpwHRV/UlWHSIyBjgIs9hOTVy+CPgPsLuIbEiTaJaMKmUQ9qGjwrmTVfXulLzL4nW3m3xCva3qQ0eG/aXxk+0moybIJ3pe/C6Rpxv4YzhcIzrfbvJx2gNXGp2KEJEhwF7h8OEK86wJfBhYDDwZu7QRNnz9lKo+n5L15rDftbbWNp8K5fMjYBxwWE5x2wMjgX+o6vz4hfDgvjUc7lJba1tDhTLaUkROEJGTROQgyZ6/Odj60Gcxy851IjJRRI4WkZNF5HNhKkOSAScfqP45JCJrAZ/Ehnx/kbg84GSUI5/Hwn7vRJ4CNqxdwoafIwacfJy+42EEnVREZHXgGGyoZA2gCLwP+IWq/j4jz7bAPli/moA9rMcCx6rq67Gkm4b9UxnVPx32m/TlHhpJtfIRkU8BhwCHq+oLOcX3e/lAbX0IOD5x3C0ilwMnJCza/V5GlconLGrYApiDzR0+hxWf3e+KyHGqemXsXL+XD9Tch+J8ARuynZb8AGMAyKhK+ZyLPZ/PFJFdgAewYe7dgLWxZ9ODsfT9Xj5O/XGl0clideC02LEC52ETyrPYNpFnPnCoql6TSDc27OdllBOdT5vU3i5ULJ9g7fgpcLOqXlFB2QNBPlBdH3oeOBZb6DELk8FHgO8AXwRWwaxtEQNBRpXKZzXsWf0eTB5nAFcCC4H9gR8Cl4vITFWNLEUDQT5Q23MIWD68eng4/GlKkoEgo4rlo6qvicj2WN/5FD0WQgUuwxZXxRkI8nHqjA9PO6mo6hOqKtjLan3gK9jcoL+KyGoZeX4S8ozE5rpcBfxMRDLn7/VXqpTPZSHd4QwiqpGRqv5FVS9S1adUdYGqvqyqndgQ/JvAgSKyRbPvoZFUIZ/oOT0EuFxVz1DVWao6N3yEnIJZmr7RxOY3hVqeQzE+gc3je0ATK+8HCtXIJ6ye/ivwX9gQ9lhgPHA08DngPhHZoGmNd/olrjQ6ZVHVblV9QVUvwCw+22OWjnJ5Fqnqv1X1eGzy+RdF5DOxJNEX6tjeuVc4/1Yfmt4U8uQjIgdjw/THq+rsCosdMPKB2vpQLO+LwJ/C4cdilwaMjCqQT9zS89uUIqJz26Xk6ffygZr7ULQAJs3KCANIRhXKZxqmMP63qt6sqm+r6iuqeilwKrAWK1otB4x8nPrhSqNTDdHE5537mCdaFJM1FyZa9Zc1l6ZdSbvXrcP+akk4Gg7n142di4Z5Bqp8oLY+NCfsR8fODVQZ9ZKPqi4AXgyHaS/oN8N+ZOzcQJUPVNCHwiK8/UhfABMxUGXUSz7BcfdOwBuqmraA6M9hv03s3ECVj9MHfE6jUw3rhn2m4+oK8zwLvABsIiIbpKzM2zPs76B/kXavd2FOvNM4DFgA/DIcLw77u7H5ajuKyMrxCfxhpeNu4TB60PcnaulDHw77uDPzwdSHwOabHQp8EHPQHOeDYR+XwUCVD1TWhw4lewFMxECVUZp8Vgr7VURkJVVdksgTudqJnx+o8nH6gFsanRUQka2D24bk+THABeHwj4lr2yXTh/Mb0TMhe3me4Icsmud4blCEojz7AR8FHgf+UuNtNIxq5aOq16vq4WlbSPJm7NzCkOcd4BrMsjY1UdUxWASQW7WJEWGqocY+tG1K+oKInAzsALwO3BJdG0x9KHAx5hLlJBGJ+9IbAZwdDqOPj34tH6hZRlGa+AKYS9PSQP+WUQ3PobnAvzFDUTI61wjgm+FweixPv5WP0zg8jOAgQET2x1ZZgrlW2B2z2vwtnHtdVf8vpL0RCxk1A/vKXICFjdoTWyU3A9hdVwxX9hYW2u5BbBhtKObja4/w94WqelyiTcOxL9TJWHiq6ZhPsFaE72qofMrUq1QeRvBeYDN6wghOVtVna7nfWmhCH1LgUeBfwEvYfKkdMSvaAuBTqnpbok2Dqg+JyLeB07H//++ARaGejUOej8fdErWTfEJ7mvI7E4t3fzu2AGab5PVE2raRURN+Y5/AFMmVMGv1DGxKw57YIppnsGhDc2N52kY+TpugbRCWxrfGbpi1SstsM2Np9wauxeapzAOWYi+p27GJ5UNTyj8O+AMWqWQBNsz6AhZ6avcy7RqFTdZ+OuSZE/K8fyDJp0y9SkYYwXB9Ncxq8B/sAf0y5i5jwgDsQ9/DLBazMWVoAfAEFgFnQ+9Dy/N+GlsB+3aQ02PYIobh7SyfJsvo+lDeFytsV1vIqBnyATbHRjFewJ4pC0MfOgdYtZ3l41t7bG5pdBzHcRzHcXLxOY2O4ziO4zhOLq40Oo7jOI7jOLm40ug4juM4juPk4kqj4ziO4ziOk4srjY7jOI7jOE4urjQ6juM4juM4ubjS6DiO4ziO4+TiSqPjDBJEZGcRURGZ2sdypoRyou2W/FyOUzki8miij+3c6jY5juNKo+OUJfHiqmSb0uo2N5GbsLB218ZPpiiV0TZfRB4QkVNEZFSyMBGZlibD2Plo6xaReSLyrIjcKCLHhLCLDUdENhaRb4jIHSLyoogsEZFXReQmEdmlwjKGx5SiWRlp7szpZyMS6adW0DdTw06KyD6hvnki8o6I3CMih+TcwyEicm9IPy/k36dM+iEi8hUReVhEForIGyLyJxGZnJHlEqxveVxjx2kjhra6AY7T5pyecu4ELDbyBcBbiWsPNbxF7cONqjqtzPV/ATeGvwtYPN1PAmcDe4jILqraXUV9N9Ej35WxWLsfxeJxny0ix+e0px6cCRwAPA78CXgD2BTYF9g3tOFHOWWcg8X6rYS0/gewLHF8Z5kyPglsDdycvCAixwAXAnMx5X8J8Blgmoj8l4ZYx4k85wFfA2YBl2GxjP8X+L2IHKuqFyXSC3BdKPdJLDTkapgc/yoi/62qN8XzqOolIe9UYKcy9+Y4TjNpdRxD33zrbxswE4sFO7HVbamy3TuHdk/tYzlTQjlTcq5PS7m2Khb3VoGdE9empZWbdT5cG4rF2l0Y0hzYYBlOAbZKOb8TpnAtBsbn/A9KwFGUiT2OKYFah/YOAV4MdW2euDYRi189N96XgXHAMyHPDok8k8P5Z4BxibLmhvImJvIcGPL8AxgRO/+hIK/XgJUz2j81ra/45ptvrdl8eNpxGkBseHG4iJwlIs+LyOIwpHqaiKyUkW9SGI6ND33+QkQ2TUm7iYh8V0TuF5E5ofz/iMhPRWRCFW0dISK/Cu29WEQa9lxQ1beA+8LhGnUob5mq/hT4Ujh1voiM7Gu5ZeqbpqoPppz/C6borYQpVr0QkVUwBXi6qv6kUW1MsBcwAbhbVR9OXPsCMBy4SFVnRidV9U3MGgqm3MaJjs8O6aI8M4GLQ3mHJvIcHfbfVNVFsTz3Addj/eAzVd2V4zgtwZVGx2ksN2Av599jw3KKWU9+HYbtliMiewAPAJ/DFKsfAtOBTwP3isjWibI/jb3EXwR+iQ0zPg4cDtwnIuvmNU5ExgFdoayTVfXLqlqq6U4rQETGYhamEtBL+eoDVwP/wYbAd61judWwNOyTQ8cRP8KseIdVWqCIHCAiJ4nIV0VkTxEZXmWbjgz7n6Zci+SUtpDp5kSamvKEuZeTgQXA36qox3GcNsTnNDpOY9kM+EBklRGRU4E/A/sAnweuCefHYYrfAuBjqvp4VICIfBC4G7gcm5sWcQ3wA1VdHK9QRHbDXsbfpMfK0wsRWT+kex9wkKr+vE932pstpWeldgFYC7vvscBxqvpMvSpS1ZKI/A2bK7gd8Md6lV0JQZYfx/5/f025/ingEOBwVX2hiqKvSxy/JiJfVtVfVdCmCcCewDzMopcksl4/lbygqi+LyLvABBEZpaoLRGQ0sC7wjqq+nFLe02G/SezcRtgQ+XOqmqZMp+VxHKdNcaXRcRrLmYlhvEUicjKmOH6BoDQCB2Pz/Y6JK4whz6Michlwgoi8P7quqi+lVaiqt4nIY8DuWY0SkS2xhRyjgT1VdXrNd5jNFmFL8kvgjgbUF8mjz8Pe1RCsfz/HhmZPjP+/w/W1MEvfzap6RYXF3gSch1lj52LK8CHYApTrRWRvVc1zdXQYprBdq6oLUq6PDft5GfnnYf1jLKYMV5IerB9XU0cyj+M4bYorjY7TWNJchvwd6Aa2ip3bIey3kHQ/ipElZjNsCDpalfo5bHHGFtjQ55BYniUZbfoI8FVgPmbV/FfeTdTI1ao6JToIytMnsFXn+4jIzqr6QB3ri4b7NTehyAn0VlRuVNWqVr+LyBBM8d8Rs+adl5LsMuxZe3il5arqDxKnngROEZHZ2DSE75A+RBy1q0DPMPilldbrOI5TDlcaHaexvJo8oarLROR1YM3Y6cjP4BE55Y2J/X0+5v7nZeBWzNK2MFybQrZbl60wlzUzgCdy6qsbqvoq8POwUOUyTPHJtIbWwDphP6eCtCfQWz4zqcJlUlAYrwU6sLmrn1dVTaQ5GHN5c4iqzq607DJcDvwAG/pfWVXnZ6TbE3NJdLeqPpKRZh6wOmYNnJtyPWklnJc4n5U+7oaqljyO47QprjQ6TmNZC3MxsxwRGYq9rN+OnY5erlukrHLthYisCRwHPApMTioPInJgmewXYQrrUcDvRGR/VV1YJn29uSfst6tXgcGy9rFE+Zmo6sQ+1jcMG5LuAH4BHKzpPiejOahXi8jVKdfXFZFI0RwXVpdnEqY3zMesyqMxa3Ea0QKYclbGJ7F+uAlwV/yCiIwP5c+KhrZV9V0ReSm0eXzKvMaNwz4+R/JZzKq+oYgMTZnXmJbHcZw2xVdPO05jSXNM/BFsGDm+evjusP9oheVuiP1+b0tRGCeE61moqh6Nrc7eDfhjWOTQLMaFfT2fP1OA92JW1z/XsdxeBHdJnZjC+DNsEVGWk/K7gCsyNrC5gtHx4rQCEnVvislvPvB6Rpp1gL3JXgATEc0r3SPl2p6JNDXlCS52ZgCjSO/bWfU4jtOGuNLoOI3lW2FlNLDcBcl3wuFVsXRXYUN0p4lILwuciBRkxfi7M8P+I2GYNEo3hp45dGVR1a+EtuwC3Br8CDaU0Nbjw+GddShvqIgcgfkIVOArcV+A9SYsevktFoXmCuDQci6KVPV6VT08bQtJ3oydWxjq2EBEVkupew16+sx1GauRoWcBzDU5FuSrMEX1GBGZGKtnHHBKOEz6k4yOT03064nAl0N5VyXy/Djsz5JY+EMR+RAWFWYO8Osy7XQcp03w4WnHaSz/Bh4TkV9hfvz2w9yQ/JGeldOo6lwR+QymkNwtItOBxzBFaD1socx7gBEh/Ssich0Wvu0hEbkNmx9WxKJyPARsmdc4VT1FRBZh4eq6RGSP5OrfPhB3uQM2JL4r5urldeDEKsvbP6bcjMYsix8FxmNWtSNVtZxlrR78BHOY/To2h/TbCXebAHeq6p19qGMn4Cci8nfgOSxU4XtDvWOB+8mQXWIBTJpvxuWo6vMi8nXMf+T9InI9PWEEJwDfV9W7EnlmiMj52EKqh0O/XglT/lYDjo07Cg9ch/kB/QzwoIj8HuvLB2DK7RGq+jaO47Q9rjQ6TmP5H+Bb2CrndTBFYyrw3eSiCVWdLiKbA/+HLRD5KPYSn40N3yWtMYdhSsUBmJVnDvA74NspaTNR1TNEZCFwLjBdRHZT1dShzypJutxZhFlILwDOTVkYEllMs1Z97xe2EvAudr/3ArcDv1DVN+rQ5jw2CPvVMTlncWcf6vgnpmhtgy1aWgUbjn4EW3BzqapmyWh3bIFPuQUwy1HVC0VkJtbnDsZGnx7HorekzcFEVb8mIo9gfe5I7P/xAPA9Vf1DSnoNc2xnYG6mjsX6wl+Bs1R1Rl47HcdpDyTx3nIcpw6IyJ3ATqraywzV3xGRKdgQ5KGqOq2O5d6KzbEsqurt9SrX6b8ES/VpwC59tN46jlMHfE6j4zi1clWIV53nZDqX4MNxMjaE/88+t8zp14jIo2FV+WmtbovjOD348LTjONXyEDYHMqLmcIAisj/m8Ht/zAflRXWcU+n0Xy5hRT+mM1vUDsdxYvjwtOM0gIE8PF1PRGQacCDwPLYw6Ltl3Nc4juM4LcSVRsdxHMdxHCcXn9PoOI7jOI7j5OJKo+M4juM4jpOLK42O4ziO4zhOLq40Oo7jOI7jOLm40ug4juM4juPk8v8Bn3kIMP/0TQ8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,4))\n", + "plt.scatter(cnn.val_pred_table['tpeak'], cnn.val_pred_table['pred_s0002'],\n", + " c=cnn.val_pred_table['gt'], vmin=0, vmax=1)\n", + "plt.xlabel('Tpeak [BJD - 2457000]')\n", + "plt.ylabel('Probability of Flare')\n", + "plt.colorbar(label='Ground Truth');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Most of the points with high probabilities are actually flares (ground truth = 1), which is great! The CNN is not perfect, but here is where ensembling a bunch of different models with different initial random seeds. By averaging across models, you can beat down the number of false positives (no flares with high probabilities) and false negatives (flares with low probabilities)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 1.3 Evaluating your Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "How do you know if the model you created and trained is good? There are a few different metrics you can look at. The first is looking at your loss and accuracy histories. Here are some features you should look for:\n", + "\n", + "- If your training and validation loss smoothly decline and flatten out at a low number, that's good!\n", + "\n", + "- If your validation loss traces your training loss, that's good!\n", + "\n", + "- If your validation loss starts to increase, your model is beginning to overfit. Rerun the model for fewer epochs and this should solve the issue." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(7,4))\n", + "plt.plot(cnn.history_table['loss_s0002'], 'k', label='Training', lw=3)\n", + "plt.plot(cnn.history_table['val_loss_s0002'], 'darkorange', label='Validation', lw=3)\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some of the same rules as above apply here:\n", + "\n", + "- If your accuracy increases smoothly and levels out at a high number, that's good! It means your model is at that leveling value % accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(7,4))\n", + "plt.plot(cnn.history_table['accuracy_s0002'], 'k', label='Training', lw=3)\n", + "plt.plot(cnn.history_table['val_accuracy_s0002'], 'darkorange', label='Validation', lw=3)\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 1.4 Predicting Flares in your Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The function to predict on light curves takes care of the pre-processing for you. All you have to do is pass in an array of times, fluxes, and flux errors. So load in your files in whatever manner you like. For this example, we'll call a light curve using lightkurve." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "//anaconda3/lib/python3.7/site-packages/lightkurve/lightcurvefile.py:47: LightkurveWarning: `LightCurveFile.header` is deprecated, please use `LightCurveFile.get_header()` instead.\n", + " LightkurveWarning)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#### create a lightkurve for a two minute target here for the example\n", + "from lightkurve.search import search_lightcurvefile\n", + "lc = search_lightcurvefile(target='tic62124646', mission='TESS')\n", + "lc = lc.download().PDCSAP_FLUX\n", + "lc.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can use the model we saved to predict flares on new light curves! This is where it becomes important to keep track of your models and your output directory. To be extra sure you know what model you're using, in order to predict on new light curves you $\\textit{must}$ input the model filename." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1/1 [00:00<00:00, 1.29it/s]\n" + ] + } + ], + "source": [ + "cnn.predict(modelname='/Users/arcticfox/Desktop/results/ensemble_s0002_i0050_b0.73.keras',\n times=lc.time, \n fluxes=lc.flux, \n errs=lc.flux_err)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Et voila... Predictions!" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(14,4))\n", + "plt.scatter(cnn.predict_time[0], cnn.predict_flux[0],\n", + " c=cnn.predictions[0], vmin=0, vmax=1)\n", + "plt.colorbar(label='Probability of Flare')\n", + "plt.xlabel('Time [BJD-2457000]')\n", + "plt.ylabel('Normalized Flux')\n", + "plt.title('TIC {}'.format(lc.targetid));" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/docs/getting_started/tutorial.md b/docs/getting_started/tutorial.md new file mode 100644 index 0000000..73307f9 --- /dev/null +++ b/docs/getting_started/tutorial.md @@ -0,0 +1,114 @@ +# Tutorial + +This tutorial walks through creating a dataset, initializing a CNN, training, inspecting metrics, and predicting on a TESS light curve. + +Prerequisites +------------- +- Install dev deps and pick a backend: + +```bash +export KERAS_BACKEND=jax # or torch +pip install -e .[dev] +``` + +Imports +------- +```python +import numpy as np +import matplotlib.pyplot as plt +from tqdm.auto import tqdm + +import stella +from stella.download_nn_set import DownloadSets +from stella.preprocessing_flares import FlareDataSet +from stella.neural_network import ConvNN +from stella.models import get_model_path, list_model_paths +from lightkurve.search import search_lightcurve +``` + +1) Download a small catalog subset (optional) +-------------------------------------------- +```python +download = DownloadSets(fn_dir='.') +download.download_catalog() +# use a smaller subset for the tutorial +download.flare_table = download.flare_table[:100] +download.download_lightcurves() +``` + +2) Build a dataset +------------------ +If you already have local files, point to them directly; otherwise pass the `DownloadSets` helper. + +```python +# Example local paths; change to your data if needed +FN_DIR = './data/unlabeled' +CATALOG = './data/unlabeled/catalog_per_flare_final.csv' + +# Choose one of the following: +# ds = FlareDataSet(downloadSet=download) +ds = FlareDataSet(fn_dir=FN_DIR, catalog=CATALOG) +``` + +Inspect a few training examples +------------------------------- +```python +ind_pc = np.where(ds.train_labels == 1)[0] +ind_nc = np.where(ds.train_labels == 0)[0] +fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(10,3), sharex=True, sharey=True) +ax1.plot(ds.train_data[ind_pc[10]], 'r'); ax1.set_title('Flare'); ax1.set_xlabel('Cadences') +ax2.plot(ds.train_data[ind_nc[10]], 'k'); ax2.set_title('No Flare'); ax2.set_xlabel('Cadences') +plt.show() +``` + +3) Initialize and train a model +------------------------------- +```python +cnn = ConvNN(output_dir='./results', ds=ds) +# Train a (short) run for the tutorial +cnn.train_models(seeds=2, epochs=50) +``` + +4) Inspect training history +--------------------------- +```python +plt.figure(figsize=(7,4)) +plt.plot(cnn.history_table['loss_s0002'], 'k', label='Training', lw=3) +plt.plot(cnn.history_table['val_loss_s0002'], 'darkorange', label='Validation', lw=3) +plt.xlabel('Epochs'); plt.ylabel('Loss'); plt.legend(); plt.show() +``` + +5) Predict on a TESS light curve +-------------------------------- +```python +lk = search_lightcurve(target='TIC 62124646', mission='TESS', sector=13, exptime=120).download().PDCSAP_FLUX +lk = lk.remove_nans().normalize() + +cnn = ConvNN(output_dir='.') +model_path = get_model_path() # packaged model +err_arr = (lk.flux_err.value if getattr(lk, 'flux_err', None) is not None else np.zeros_like(lk.time.value)) +cnn.predict(modelname=model_path, times=lk.time.value, fluxes=lk.flux.value, errs=err_arr, verbose=False) +``` + +Plot predictions +---------------- +```python +plt.figure(figsize=(14,4)) +plt.scatter(cnn.predict_time[0], cnn.predict_flux[0], c=cnn.predictions[0], vmin=0, vmax=1) +plt.colorbar(label='Probability of Flare') +plt.xlabel('Time [BJD-2457000]'); plt.ylabel('Normalized Flux'); +plt.title(f'TIC {lk.targetid}') +plt.show() +``` + +Ensembling (optional) +--------------------- +```python +MODELS = list_model_paths() +preds = [] +for mp in MODELS: + cnn.predict(modelname=mp, times=lk.time.value, fluxes=lk.flux.value, errs=err_arr, verbose=False) + preds.append(cnn.predictions[0]) +import numpy as _np +avg_pred = _np.nanmedian(_np.vstack(preds), axis=0) +``` diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..140fa6b --- /dev/null +++ b/docs/index.md @@ -0,0 +1,31 @@ +# stella + +![stella logo](assets/stella_logo.png) + +stella is an open-source Python framework for identifying stellar flares in TESS two-minute cadence data using convolutional neural networks (Keras 3 on JAX or PyTorch). + +- Backends: set `KERAS_BACKEND` to `jax` (default) or `torch`. +- Packaged models: `from stella import models as sm; sm.models`. +- Quickstart notebooks live under [Getting Started](getting_started/about.md). + +Getting started +--------------- + +```bash +export KERAS_BACKEND=jax # or torch +pip install -e .[dev] +``` + +Citations +--------- +- [Feinstein, Montet, & Ansdell (2020), JOSS](https://ui.adsabs.harvard.edu/abs/2020JOSS....5.2347F/abstract) +- [Feinstein et al. (2020, arXiv)](https://ui.adsabs.harvard.edu/abs/2020arXiv200507710F/abstract) + +Bug reports and contributions +----------------------------- +stella is MIT-licensed. + +Source and issues on GitHub: + +- [Repo](https://github.com/benjaminpope/stella) +- [Issues](https://github.com/benjaminpope/stella/issues) diff --git a/docs/index.rst b/docs/index.rst index c44405b..2d40a2f 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -21,6 +21,8 @@ stella is an open-source python framework for identifying stellar flares using a getting_started/shortest_demo getting_started/tutorial getting_started/other_features + getting_started/pipeline + getting_started/backends .. toctree:: :maxdepth: 2 diff --git a/mkdocs.yml b/mkdocs.yml new file mode 100644 index 0000000..78d92a9 --- /dev/null +++ b/mkdocs.yml @@ -0,0 +1,47 @@ +site_name: stella +site_description: "Find stellar flares in TESS 2-min data with a CNN" +repo_url: https://github.com/benjaminpope/stella +repo_name: benjaminpope/stella +docs_dir: docs +site_dir: site + +theme: + name: material + +plugins: + - search + - mkdocstrings: + handlers: + python: + options: + docstring_style: numpy + show_source: false + inherited_members: true + - mkdocs-jupyter: + execute: false + - exclude: + glob: + - getting_started/tutorial.md + - getting_started/shortest_demo.md + - getting_started/other_features.md + +markdown_extensions: + - admonition + - toc: + permalink: true + - tables + - fenced_code + - codehilite + +nav: + - Home: index.md + - Getting Started: + - About: getting_started/about.md + - Installation: getting_started/installation.md + - Pipeline: getting_started/pipeline.md + - Backends: getting_started/backends.md + - Tutorial (notebook): getting_started/tutorial.ipynb + - Shortest Demo (notebook): getting_started/shortest_demo.ipynb + - Other Features (notebook): getting_started/other_features.ipynb + - API: + - stella: api.md diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..e332c78 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,99 @@ +[build-system] +requires = ["setuptools>=68", "wheel"] +build-backend = "setuptools.build_meta" + +[project] +name = "stella" +description = "Find stellar flares in TESS 2-min data with a CNN" +readme = "README.md" +license = { file = "LICENSE" } +authors = [ + { name = "Adina D. Feinstein", email = "adina.d.feinstein@gmail.com" } +] +requires-python = ">=3.8" +dynamic = ["version"] +keywords = ["astronomy", "tess", "flares", "keras", "jax", "pytorch"] +classifiers = [ + "Development Status :: 3 - Alpha", + "Intended Audience :: Science/Research", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", +] +dependencies = [ + "keras>=3.0.0", + "numpy", + "astropy", + "scikit-learn", + "scipy!=1.4.1", + "tqdm", + "lightkurve>=2.0.0", +] + +[project.optional-dependencies] +jax = [ + "jax>=0.4.20", + "jaxlib>=0.4.20", +] +# JAX on Apple Silicon with Metal (macOS only) +jax-mps = [ + "jax>=0.4.20", + "jaxlib>=0.4.20", + "jax-metal>=0.0.7; platform_system=='Darwin'", +] +torch = [ + "torch>=2.2.0", +] +dev = [ + "pytest", + "pytest-cov", + "nbsphinx", + "ipykernel", + "coverage", + "codecov", + "pre-commit", + "sphinx>=7.0", + "sphinx_rtd_theme>=1.3", + "mkdocs>=1.6", + "mkdocs-material>=9.5", + "mkdocstrings[python]>=0.25", + "mkdocs-jupyter>=0.25", + "mkdocs-exclude>=1.0", + "rich>=13.0", +] +all-backends = [ + "stella[jax,torch]", +] + +[tool.setuptools] +include-package-data = true + +[tool.setuptools.packages.find] +include = ["stella", "stella.*"] + +[tool.setuptools.package-data] +"stella" = ["data/*.keras"] + +[tool.setuptools.dynamic] +version = { attr = "stella.version.__version__" } + +[tool.black] +line-length = 88 +target-version = ["py38"] +include = '\.pyi?$' +exclude = ''' +/( + \.eggs|\.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv| + _build|buck-out|build|dist|stella\.egg-info|docs/_build|mastDownload|run01 +)/ +''' + +[tool.pytest.ini_options] +addopts = "-x --doctest-modules" +testpaths = [ + "stella/tests", +] diff --git a/requirements-jax.txt b/requirements-jax.txt new file mode 100644 index 0000000..a611470 --- /dev/null +++ b/requirements-jax.txt @@ -0,0 +1,3 @@ +-r requirements.txt +jax>=0.4.20 +jaxlib>=0.4.20 diff --git a/requirements-torch.txt b/requirements-torch.txt new file mode 100644 index 0000000..64b4ec4 --- /dev/null +++ b/requirements-torch.txt @@ -0,0 +1,2 @@ +-r requirements.txt +torch>=2.2.0 diff --git a/requirements.txt b/requirements.txt index 14ffd72..0fc7985 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,6 +1,6 @@ nbsphinx ipykernel -tensorflow>=2.1.0 +keras>=3.0.0 astroquery astropy tqdm diff --git a/setup.cfg b/setup.cfg deleted file mode 100644 index dcc6fdb..0000000 --- a/setup.cfg +++ /dev/null @@ -1,8 +0,0 @@ -[wheel] -universal=1 - -[aliases] -test=pytest - -[tool:pytest] -addopts = -x --doctest-modules --ignore=setup.py --cov=stella diff --git a/setup.py b/setup.py deleted file mode 100644 index 248997b..0000000 --- a/setup.py +++ /dev/null @@ -1,54 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -from __future__ import division, print_function - -import os -import sys -from setuptools import setup - -sys.path.insert(0, "stella") -from version import __version__ - - -long_description = \ - """ -stella is a python package to identify and characterize flares in -TESS short-cadence data using a convolutional neural network. In its -simplest form, stella takes an array of light curves and predicts where -flares are using the models provided in Feinstein et al. submitted and -returns predictions. - -Read the documentation at https://adina.feinste.in/stella - -Changes to v0.1.0 (2020-05-18): -* -""" - -with open('requirements.txt') as f: - install_requires = f.read().splitlines() - -setup( - name='stella', - version=__version__, - license='MIT', - author='Adina D. Feinstein', - author_email='adina.d.feinstein@gmail.com', - packages=[ - 'stella', - ], - include_package_data=True, - url='http://github.com/afeinstein20/stella', - description='For finding flares in TESS 2-min data with a CNN', - long_description=long_description, - long_description_content_type="text/markdown", - package_data={'': ['README.md', 'LICENSE']}, - install_requires=install_requires, - classifiers=[ - 'Development Status :: 3 - Alpha', - 'Intended Audience :: Science/Research', - 'License :: OSI Approved :: MIT License', - 'Operating System :: OS Independent', - 'Programming Language :: Python :: 3.7', - ], - ) diff --git a/stella.egg-info/PKG-INFO b/stella.egg-info/PKG-INFO index 9381f7c..d27454b 100644 --- a/stella.egg-info/PKG-INFO +++ b/stella.egg-info/PKG-INFO @@ -1,27 +1,171 @@ -Metadata-Version: 2.1 +Metadata-Version: 2.4 Name: stella -Version: 0.2.0rc2 -Summary: For finding flares in TESS 2-min data with a CNN -Home-page: http://github.com/afeinstein20/stella -Author: Adina D. Feinstein -Author-email: adina.d.feinstein@gmail.com -License: MIT -Description: - stella is a python package to identify and characterize flares in - TESS short-cadence data using a convolutional neural network. In its - simplest form, stella takes an array of light curves and predicts where - flares are using the models provided in Feinstein et al. submitted and - returns predictions. +Version: 0.3.0 +Summary: Find stellar flares in TESS 2-min data with a CNN +Author-email: "Adina D. Feinstein" +License: MIT License - Read the documentation at https://adina.feinste.in/stella + Copyright (c) 2019 Adina Feinstein - Changes to v0.1.0 (2020-05-18): - * + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: -Platform: UNKNOWN + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + +Keywords: astronomy,tess,flares,keras,jax,pytorch Classifier: Development Status :: 3 - Alpha Classifier: Intended Audience :: Science/Research Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent -Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Requires-Python: >=3.8 Description-Content-Type: text/markdown +License-File: LICENSE +Requires-Dist: keras>=3.0.0 +Requires-Dist: numpy +Requires-Dist: astropy +Requires-Dist: scikit-learn +Requires-Dist: scipy!=1.4.1 +Requires-Dist: tqdm +Requires-Dist: lightkurve>=2.0.0 +Provides-Extra: jax +Requires-Dist: jax>=0.4.20; extra == "jax" +Requires-Dist: jaxlib>=0.4.20; extra == "jax" +Provides-Extra: jax-mps +Requires-Dist: jax>=0.4.20; extra == "jax-mps" +Requires-Dist: jaxlib>=0.4.20; extra == "jax-mps" +Requires-Dist: jax-metal>=0.0.7; platform_system == "Darwin" and extra == "jax-mps" +Provides-Extra: torch +Requires-Dist: torch>=2.2.0; extra == "torch" +Provides-Extra: dev +Requires-Dist: pytest; extra == "dev" +Requires-Dist: pytest-cov; extra == "dev" +Requires-Dist: nbsphinx; extra == "dev" +Requires-Dist: ipykernel; extra == "dev" +Requires-Dist: coverage; extra == "dev" +Requires-Dist: codecov; extra == "dev" +Requires-Dist: pre-commit; extra == "dev" +Requires-Dist: sphinx>=7.0; extra == "dev" +Requires-Dist: sphinx_rtd_theme>=1.3; extra == "dev" +Requires-Dist: mkdocs>=1.6; extra == "dev" +Requires-Dist: mkdocs-material>=9.5; extra == "dev" +Requires-Dist: mkdocstrings[python]>=0.25; extra == "dev" +Requires-Dist: mkdocs-jupyter>=0.25; extra == "dev" +Requires-Dist: mkdocs-exclude>=1.0; extra == "dev" +Requires-Dist: rich>=13.0; extra == "dev" +Provides-Extra: all-backends +Requires-Dist: stella[jax,torch]; extra == "all-backends" +Dynamic: license-file + +

+ +

+ +

+ + + + PyPI - Downloads + + + Docs Deploy + GitHub Pages +

+ + +

+stella is a Python package to create and train a neural network to identify stellar flares. +Within stella, users can simulate flares as a training set, run a neural network, and feed +in their own data to the neural network model. stella returns a probability at each data point +that that data point is part of a flare or not. stella can also characterize the flares identified. +

+ + +To install stella with pip: + + pip install stella + +Alternatively you can install the current development version of stella: + + git clone https://github.com/afeinstein20/stella + cd stella + python setup.py install + +Backends and models +------------------- +- stella uses Keras Core and works with multiple backends: JAX or PyTorch. Choose one, install, and set it before importing `keras`: + +```bash +# JAX +pip install -r requirements-jax.txt +export KERAS_BACKEND=jax + +# or PyTorch +pip install -r requirements-torch.txt +export KERAS_BACKEND=torch +``` + + Models are saved/loaded in the native Keras format (`.keras`). If you have older `.h5` + or legacy SavedModel models, use the included converter: + +```bash +# Convert .h5 or legacy SavedModel to .keras (TensorFlow backend only for conversion) +python scripts/convert_h5_to_keras.py /path/to/models -r --cadences 350 -o /path/to/out +``` + +Pipeline quickstart +------------------- +- See the new pipeline guide for a friendly, end-to-end example (TIC 62124646): + https://afeinstein20.github.io/stella/getting_started/pipeline.html + +Swap backends quickly +--------------------- +- Inspect availability and devices: + +```python +import stella +stella.check_backend() +``` + +- Prepare a swap (restart your interpreter after): + +```python +import stella +stella.swap_backend('torch', accelerator='mps') # Apple Silicon +# or +stella.swap_backend('jax', accelerator='cpu') +``` +``` + +

+If your work uses the stella software, please cite Feinstein, Montet, & Ansdell (2020). +

+

+If your work discusses the flare rate of young stars in the TESS Southern Hemisphere or the details of the CNNs, please cite Feinstein et al. (AJ, 2020). +

+ +

+Bug Reports, Questions, & Contributions +

+

+stella is an open source project under the MIT license. +The source code is available on GitHub. In case of any questions or problems, please contact us via the Git Issues. +Pull requests are also welcome through the GitHub page. +

diff --git a/stella.egg-info/SOURCES.txt b/stella.egg-info/SOURCES.txt index 64f369b..a4c3517 100644 --- a/stella.egg-info/SOURCES.txt +++ b/stella.egg-info/SOURCES.txt @@ -9,12 +9,10 @@ codecov.yml final_models.zip paper.bib paper.md +pyproject.toml requirements.txt -setup.cfg -setup.py .ci/build-docs.sh .ci/conda.sh -.github/workflows/greetings.yml .github/workflows/stella-tests.yml docs/Makefile docs/api.rst @@ -51,10 +49,13 @@ docs/sphinx_rtd_theme/static/js/theme.js figures/stella_logo.png figures/stella_prob_slider.gif stella/__init__.py +stella/backends.py stella/download_nn_set.py stella/mark_flares.py stella/metrics.py +stella/models.py stella/neural_network.py +stella/pipeline.py stella/preprocessing_flares.py stella/rotations.py stella/utils.py @@ -65,6 +66,21 @@ stella.egg-info/SOURCES.txt stella.egg-info/dependency_links.txt stella.egg-info/requires.txt stella.egg-info/top_level.txt +stella/data/ensemble_s0004_i0350_b0.73_savedmodel.keras +stella/data/ensemble_s0005_i0350_b0.73_savedmodel.keras +stella/data/ensemble_s0018_i0350_b0.73_savedmodel.keras +stella/data/ensemble_s0028_i0350_b0.73_savedmodel.keras +stella/data/ensemble_s0029_i0350_b0.73_savedmodel.keras +stella/data/ensemble_s0038_i0350_b0.73_savedmodel.keras +stella/data/ensemble_s0050_i0350_b0.73_savedmodel.keras +stella/data/ensemble_s0077_i0350_b0.73_savedmodel.keras +stella/data/ensemble_s0078_i0350_b0.73_savedmodel.keras +stella/data/ensemble_s0080_i0350_b0.73_savedmodel.keras +stella/tests/conftest.py +stella/tests/test_backends.py +stella/tests/test_mark_flares.py stella/tests/test_neural_network.py stella/tests/test_processing.py -stella/tests/test_rotation.py \ No newline at end of file +stella/tests/test_rotation.py +stella/tests/test_swap_backend.py +stella/tests/test_training_guards.py \ No newline at end of file diff --git a/stella.egg-info/requires.txt b/stella.egg-info/requires.txt index f319be3..40c1491 100644 --- a/stella.egg-info/requires.txt +++ b/stella.egg-info/requires.txt @@ -1,21 +1,41 @@ -nbsphinx -ipykernel -tensorflow>=2.1.0 -astroquery +keras>=3.0.0 +numpy astropy +scikit-learn +scipy!=1.4.1 tqdm -cython -codecov -coverage +lightkurve>=2.0.0 + +[all-backends] +stella[jax,torch] + +[dev] pytest pytest-cov -lxml -pybind11 -tornado -matplotlib -lightkurve>=2.0.0 -numpy -sklearn -more-itertools -scipy!=1.4.1 -poetry +nbsphinx +ipykernel +coverage +codecov +pre-commit +sphinx>=7.0 +sphinx_rtd_theme>=1.3 +mkdocs>=1.6 +mkdocs-material>=9.5 +mkdocstrings[python]>=0.25 +mkdocs-jupyter>=0.25 +mkdocs-exclude>=1.0 +rich>=13.0 + +[jax] +jax>=0.4.20 +jaxlib>=0.4.20 + +[jax-mps] +jax>=0.4.20 +jaxlib>=0.4.20 + +[jax-mps:platform_system == "Darwin"] +jax-metal>=0.0.7 + +[torch] +torch>=2.2.0 diff --git a/stella/__init__.py b/stella/__init__.py index a1d3a73..5307093 100755 --- a/stella/__init__.py +++ b/stella/__init__.py @@ -1,12 +1,56 @@ import os + PACKAGEDIR = os.path.abspath(os.path.dirname(__file__)) from .version import __version__ -from .neural_network import * -from .preprocessing_flares import * -#from .preprocessing_transits import * -from .mark_flares import * -from .visualize import * -from .metrics import * -from .rotations import * -from .download_nn_set import * + +# Convenience backend utilities exposed at top-level. +from .backends import ( + check_backend, + benchmark, + swap_backend, + require_backend, +) # noqa: F401 +from . import models # noqa: F401 + +# Lazy exports for backward compatibility, avoiding heavy imports at module import time +_LAZY_EXPORTS = { + "ConvNN": ("neural_network", "ConvNN"), + "FitFlares": ("mark_flares", "FitFlares"), + "MeasureProt": ("rotations", "MeasureProt"), + "neural_network": ("neural_network", None), + "mark_flares": ("mark_flares", None), + "pipeline": ("pipeline", None), + "rotations": ("rotations", None), +} + + +def __getattr__(name): + tgt = _LAZY_EXPORTS.get(name) + if tgt is None: + raise AttributeError(f"module 'stella' has no attribute '{name}'") + mod_name, attr = tgt + mod = __import__(f"{__name__}.{mod_name}", fromlist=[attr] if attr else []) + return getattr(mod, attr) if attr else mod + + +def __dir__(): + return sorted(list(globals().keys()) + list(_LAZY_EXPORTS.keys())) + + +__all__ = [ + "__version__", + "check_backend", + "benchmark", + "swap_backend", + "require_backend", + "models", + # Back-compat lazy exports + "ConvNN", + "FitFlares", + "MeasureProt", + "neural_network", + "mark_flares", + "pipeline", + "rotations", +] diff --git a/stella/backends.py b/stella/backends.py new file mode 100644 index 0000000..f72b703 --- /dev/null +++ b/stella/backends.py @@ -0,0 +1,384 @@ +import json +import os +import sys +import time +import warnings +from typing import Dict, List, Optional + + +def _keras_current_backend() -> Optional[str]: + try: + import keras + + return keras.backend.backend() + except Exception: + return os.environ.get("KERAS_BACKEND") + + +def _jax_info() -> Dict: + info = {"name": "jax", "installed": False, "devices": [], "details": {}} + try: + import jax # type: ignore + + info["installed"] = True + devs = jax.devices() + info["devices"] = [f"{d.platform}:{d.id}" for d in devs] + kinds = sorted({d.platform for d in devs}) + info["details"]["kinds"] = kinds + except Exception as e: + info["error"] = str(e) + return info + + +def _torch_info() -> Dict: + info = {"name": "torch", "installed": False, "devices": [], "details": {}} + try: + import torch # type: ignore + + info["installed"] = True + cuda = torch.cuda.is_available() + mps = getattr(getattr(torch, "backends", None), "mps", None) + mps_avail = bool(mps.is_available()) if mps is not None else False + info["details"]["cuda"] = bool(cuda) + info["details"]["mps"] = bool(mps_avail) + if cuda: + count = torch.cuda.device_count() + for i in range(count): + info["devices"].append(f"cuda:{i}:{torch.cuda.get_device_name(i)}") + if mps_avail: + info["devices"].append("mps:0:Apple Metal") + except Exception as e: + info["error"] = str(e) + return info + + +def check_backend(print_summary: bool = True) -> Dict: + """ + Report available Keras backends and device acceleration. + + Returns a dict with keys: current, candidates, and per-backend info. + """ + current = _keras_current_backend() + jax_info = _jax_info() + torch_info = _torch_info() + candidates: List[str] = [] + if jax_info["installed"]: + candidates.append("jax") + if torch_info["installed"]: + candidates.append("torch") + + result = { + "current": current, + "candidates": candidates, + "jax": jax_info, + "torch": torch_info, + "env": {"KERAS_BACKEND": os.environ.get("KERAS_BACKEND")}, + } + + if print_summary: + lines = [ + f"Keras backend (current): {current}", + f"KERAS_BACKEND env: {os.environ.get('KERAS_BACKEND')}", + f"Available backends: {', '.join(candidates) if candidates else 'none'}", + ] + # JAX summary + if jax_info["installed"]: + kinds = ( + ", ".join(jax_info.get("details", {}).get("kinds", [])) + or "(no devices)" + ) + lines.append( + f"- jax: installed; devices={jax_info['devices']} kinds={kinds}" + ) + else: + lines.append("- jax: not installed") + # Torch summary + if torch_info["installed"]: + det = torch_info.get("details", {}) + acc = [] + if det.get("cuda"): + acc.append("CUDA") + if det.get("mps"): + acc.append("MPS") + acc_s = ", ".join(acc) if acc else "CPU" + lines.append( + f"- torch: installed; accel={acc_s}; devices={torch_info['devices']}" + ) + else: + lines.append("- torch: not installed") + print("\n".join(lines)) + + return result + + +def require_backend(backend: Optional[str] = None) -> None: + """Validate that the selected Keras backend is installed and usable. + + Parameters + ---------- + backend : str | None + Backend to require ('jax' or 'torch'). If None, uses the active + backend from KERAS_BACKEND or keras.backend.backend(). + + Raises + ------ + RuntimeError + If the required backend is not installed or has no available devices. + """ + info = check_backend(print_summary=False) + be = ( + (backend or info.get("current") or os.environ.get("KERAS_BACKEND") or "") + .strip() + .lower() + ) + # Auto-select a sensible default if none is set: prefer JAX, then Torch + if be not in ("jax", "torch"): + candidates = info.get("candidates", []) + if "jax" in candidates: + be = "jax" + elif "torch" in candidates: + be = "torch" + else: + raise RuntimeError( + "No Keras backend installed. Install one with: " + "pip install stella[jax] (or) pip install stella[torch]" + ) + os.environ["KERAS_BACKEND"] = be + + ok = be in info.get("candidates", []) + if not ok: + hint = "pip install stella[jax]" if be == "jax" else "pip install stella[torch]" + raise RuntimeError( + f"Requested backend '{be}' is not installed. Install with: {hint}" + ) + + # Optional: ensure at least CPU device present (mostly for JAX visibility) + details = info.get(be, {}) + # If nothing is reported, still allow CPU fallback; do not hard-fail here. + return + + +def _subprocess_benchmark( + model_path: str, target: str, sector: int, exptime: int, author: str +) -> Dict: + """Run the actual timed inference in a fresh process for the active KERAS_BACKEND.""" + # Silence lightkurve noisy warnings + warnings.filterwarnings( + "ignore", message=r".*tpfmodel submodule is not available.*" + ) + warnings.filterwarnings("ignore", message=r".*Lightkurve cache directory.*") + + import keras # type: ignore + import numpy as np # type: ignore + from lightkurve.search import search_lightcurvefile # type: ignore + from stella.neural_network import ConvNN # type: ignore + + # Load model once + m = keras.models.load_model(model_path, compile=False) + cadences = int(m.input_shape[1]) + + # Download + preprocess light curve + lcf = search_lightcurvefile(target=target, mission="TESS", sector=sector) + lc = lcf.download().normalize().remove_nans() + try: + lc = lc[lc.quality == 0] + except Exception: + pass + + t = lc.time.value + f = lc.flux.value + e = getattr(lc, "flux_err", None) + if e is None: + e = np.zeros_like(f) + np.nanmedian(f) * 1e-3 + else: + e = e.value + + # Warmup predict on a tiny slice to trigger JIT/graph build + cnn = ConvNN(output_dir=".") + n_warm = min(5 * cadences, len(t)) + _t0 = time.perf_counter() + cnn.predict( + modelname=model_path, times=t[:n_warm], fluxes=f[:n_warm], errs=e[:n_warm] + ) + + # Timed full predict + t0 = time.perf_counter() + cnn.predict(modelname=model_path, times=t, fluxes=f, errs=e) + dt = time.perf_counter() - t0 + + return { + "seconds": dt, + "points": int(len(t)), + "cadences": cadences, + "pred_shape": tuple(np.array(cnn.predictions, dtype=object).shape), + } + + +def benchmark( + model_path: str, + target: str = "tic62124646", + sector: int = 13, + exptime: int = 120, + author: str = "SPOC", + backends: Optional[List[str]] = None, +) -> Dict: + """ + Benchmark inference speed across available backends on a standard light curve. + + Parameters + ---------- + model_path : str + Path to a `.keras` model file. + target : str + TIC identifier (default: 'tic62124646'). + sector : int + TESS sector to download (default: 13). + exptime : int + Cadence in seconds (default: 120). + author : str + Lightkurve author (default: 'SPOC'). + backends : list[str] | None + Specific backends to test; if None, use available ones. + """ + if not model_path or not os.path.exists(os.path.expanduser(model_path)): + raise FileNotFoundError(f"Model not found: {model_path}") + model_path = os.path.expanduser(model_path) + + info = check_backend(print_summary=False) + candidates = backends or info.get("candidates", []) + if not candidates: + raise RuntimeError("No Keras backends are installed to benchmark.") + + results: Dict[str, Dict] = {} + for be in candidates: + env = os.environ.copy() + env["KERAS_BACKEND"] = be + # Build inline script to run in a fresh interpreter + code = ( + "import json, os; " + "from stella.backends import _subprocess_benchmark; " + f"res=_subprocess_benchmark({model_path!r}, {target!r}, {sector}, {exptime}, {author!r}); " + "print(json.dumps(res))" + ) + t0 = time.perf_counter() + from subprocess import Popen, PIPE + + p = Popen( + [sys.executable, "-c", code], env=env, stdout=PIPE, stderr=PIPE, text=True + ) + out, err = p.communicate() + elapsed = time.perf_counter() - t0 + if p.returncode != 0: + results[be] = {"error": err.strip(), "elapsed": elapsed} + continue + try: + # Attempt robust parse: use the last JSON-looking line + line = out.strip().splitlines()[-1] if out.strip().splitlines() else "" + if line.startswith("{") and line.endswith("}"): + payload = json.loads(line) + else: + payload = json.loads(out.strip()) + except Exception as e: + payload = {"parse_error": str(e), "raw": out} + payload["elapsed_wall"] = elapsed + results[be] = payload + + # Pretty print summary + print("Benchmark results (lower is better):") + for be, r in results.items(): + if "seconds" in r: + print( + f"- {be}: {r['seconds']:.3f}s predict (wall {r['elapsed_wall']:.3f}s), points={r.get('points')} cadences={r.get('cadences')}" + ) + else: + print(f"- {be}: ERROR {r.get('error') or r}") + + return {"backends": candidates, "results": results} + + +def _apply_accelerator_env( + backend: str, accelerator: Optional[str], env: Dict[str, str] +) -> None: + acc = (accelerator or "").lower().strip() + if backend == "torch": + if acc == "cpu": + env["CUDA_VISIBLE_DEVICES"] = "" + env["PYTORCH_ENABLE_MPS_FALLBACK"] = "1" + elif acc in ("cuda", "gpu"): + env.pop("CUDA_VISIBLE_DEVICES", None) # allow default + env["PYTORCH_ENABLE_MPS_FALLBACK"] = "0" + elif acc == "mps": + env["CUDA_VISIBLE_DEVICES"] = "" + env["PYTORCH_ENABLE_MPS_FALLBACK"] = "0" + elif backend == "jax": + if acc == "cpu": + env["JAX_PLATFORM_NAME"] = "cpu" + elif acc in ("cuda", "gpu"): + env["JAX_PLATFORM_NAME"] = "gpu" + elif acc in ("metal", "mps"): + # Experimental Apple Metal backend + env["JAX_PLATFORM_NAME"] = "metal" + + +def swap_backend( + backend: str, accelerator: Optional[str] = None, restart: bool = False +) -> Dict: + """ + Prepare environment for a different Keras backend and accelerator. + + Note: Keras backend is selected at import time. If `keras` is already + imported in this process, you must restart the interpreter for the change + to take effect. Setting `restart=True` will perform an in-place re-exec. + + Parameters + ---------- + backend : str + One of 'jax' or 'torch'. + accelerator : str | None + Optional accelerator hint: 'cpu', 'cuda'/'gpu', or 'mps' (Apple Metal). + restart : bool + If True and keras is already imported, re-exec the current process. + """ + be = backend.strip().lower() + if be not in ("jax", "torch"): + raise ValueError("backend must be 'jax' or 'torch'") + + env = os.environ.copy() + env["KERAS_BACKEND"] = be + _apply_accelerator_env(be, accelerator, env) + + already = "keras" in sys.modules + summary = { + "requested_backend": be, + "accelerator": accelerator, + "already_imported": already, + "env_preview": { + k: env.get(k) + for k in ( + "KERAS_BACKEND", + "JAX_PLATFORM_NAME", + "CUDA_VISIBLE_DEVICES", + "PYTORCH_ENABLE_MPS_FALLBACK", + ) + }, + "action": None, + } + + if already and not restart: + warnings.warn( + "Keras is already imported; backend cannot be swapped without restart. Call swap_backend(..., restart=True) to re-exec." + ) + # Apply env to current process for any child processes + os.environ.update(env) + summary["action"] = "env_set_no_restart" + return summary + + if already and restart: + # Re-exec the interpreter with new env + summary["action"] = "reexec" + os.execvpe(sys.executable, [sys.executable] + sys.argv, env) + + # Not imported yet: set env and return + os.environ.update(env) + summary["action"] = "env_set" + return summary diff --git a/stella/data/ensemble_s0004_i0350_b0.73_savedmodel.keras b/stella/data/ensemble_s0004_i0350_b0.73_savedmodel.keras new file mode 100644 index 0000000..957210d Binary files /dev/null and b/stella/data/ensemble_s0004_i0350_b0.73_savedmodel.keras differ diff --git a/stella/data/ensemble_s0005_i0350_b0.73_savedmodel.keras b/stella/data/ensemble_s0005_i0350_b0.73_savedmodel.keras new file mode 100644 index 0000000..b3b40fc Binary files /dev/null and b/stella/data/ensemble_s0005_i0350_b0.73_savedmodel.keras differ diff --git a/stella/data/ensemble_s0018_i0350_b0.73_savedmodel.keras b/stella/data/ensemble_s0018_i0350_b0.73_savedmodel.keras new file mode 100644 index 0000000..f58434b Binary files /dev/null and b/stella/data/ensemble_s0018_i0350_b0.73_savedmodel.keras differ diff --git a/stella/data/ensemble_s0028_i0350_b0.73_savedmodel.keras b/stella/data/ensemble_s0028_i0350_b0.73_savedmodel.keras new file mode 100644 index 0000000..d4ebb00 Binary files /dev/null and b/stella/data/ensemble_s0028_i0350_b0.73_savedmodel.keras differ diff --git a/stella/data/ensemble_s0029_i0350_b0.73_savedmodel.keras b/stella/data/ensemble_s0029_i0350_b0.73_savedmodel.keras new file mode 100644 index 0000000..8c481c0 Binary files /dev/null and b/stella/data/ensemble_s0029_i0350_b0.73_savedmodel.keras differ diff --git a/stella/data/ensemble_s0038_i0350_b0.73_savedmodel.keras b/stella/data/ensemble_s0038_i0350_b0.73_savedmodel.keras new file mode 100644 index 0000000..4fd08d5 Binary files /dev/null and b/stella/data/ensemble_s0038_i0350_b0.73_savedmodel.keras differ diff --git a/stella/data/ensemble_s0050_i0350_b0.73_savedmodel.keras b/stella/data/ensemble_s0050_i0350_b0.73_savedmodel.keras new file mode 100644 index 0000000..0eb885f Binary files /dev/null and b/stella/data/ensemble_s0050_i0350_b0.73_savedmodel.keras differ diff --git a/stella/data/ensemble_s0077_i0350_b0.73_savedmodel.keras b/stella/data/ensemble_s0077_i0350_b0.73_savedmodel.keras new file mode 100644 index 0000000..04ca4f9 Binary files /dev/null and b/stella/data/ensemble_s0077_i0350_b0.73_savedmodel.keras differ diff --git a/stella/data/ensemble_s0078_i0350_b0.73_savedmodel.keras b/stella/data/ensemble_s0078_i0350_b0.73_savedmodel.keras new file mode 100644 index 0000000..55543c4 Binary files /dev/null and b/stella/data/ensemble_s0078_i0350_b0.73_savedmodel.keras differ diff --git a/stella/data/ensemble_s0080_i0350_b0.73_savedmodel.keras b/stella/data/ensemble_s0080_i0350_b0.73_savedmodel.keras new file mode 100644 index 0000000..ef20db0 Binary files /dev/null and b/stella/data/ensemble_s0080_i0350_b0.73_savedmodel.keras differ diff --git a/stella/download_nn_set.py b/stella/download_nn_set.py index daf36ca..095055c 100644 --- a/stella/download_nn_set.py +++ b/stella/download_nn_set.py @@ -5,7 +5,8 @@ from astroquery.vizier import Vizier from lightkurve.search import search_lightcurve -__all__ = ['DownloadSets'] +__all__ = ["DownloadSets"] + class DownloadSets(object): """ @@ -17,7 +18,6 @@ class DownloadSets(object): """ def __init__(self, fn_dir=None, flare_catalog_name=None): - """ Parameters ---------- @@ -36,7 +36,7 @@ def __init__(self, fn_dir=None, flare_catalog_name=None): if fn_dir != None: self.fn_dir = fn_dir else: - self.fn_dir = os.path.join(os.path.expanduser('~'), '.stella') + self.fn_dir = os.path.join(os.path.expanduser("~"), ".stella") if os.path.isdir(self.fn_dir) == False: os.mkdir(self.fn_dir) @@ -44,11 +44,10 @@ def __init__(self, fn_dir=None, flare_catalog_name=None): self.flare_table = None if flare_catalog_name is None: - self.flare_catalog_name = 'Guenther_2020_flare_catalog.txt' + self.flare_catalog_name = "Guenther_2020_flare_catalog.txt" else: self.flare_catalog_name = flare_catalog_name - def download_catalog(self): """ Downloads the flare catalog using Vizier. @@ -63,16 +62,18 @@ def download_catalog(self): Vizier.ROW_LIMIT = -1 - catalog_list = Vizier.find_catalogs('TESS flares sectors') + catalog_list = Vizier.find_catalogs("TESS flares sectors") catalogs = Vizier.get_catalogs(catalog_list.keys()) self.flare_table = catalogs[1] - self.flare_table.rename_column('_tab2_5', 'tpeak') - self.flare_table.write(os.path.join(self.fn_dir, self.flare_catalog_name), - format='csv', overwrite=True) + self.flare_table.rename_column("_tab2_5", "tpeak") + self.flare_table.write( + os.path.join(self.fn_dir, self.flare_catalog_name), + format="csv", + overwrite=True, + ) return - def download_lightcurves(self, remove_fits=True): """ Downloads light curves for the training, validation, and @@ -85,21 +86,21 @@ def download_lightcurves(self, remove_fits=True): files when done. This will save space. Default is True. """ if self.flare_table is None: - self.flare_table = Table.read(os.path.join(self.fn_dir, - self.flare_catalog_name), - format='ascii') - + self.flare_table = Table.read( + os.path.join(self.fn_dir, self.flare_catalog_name), format="ascii" + ) - tics = np.unique(self.flare_table['TIC']) - npy_name = '{0:09d}_sector{1:02d}.npy' + tics = np.unique(self.flare_table["TIC"]) + npy_name = "{0:09d}_sector{1:02d}.npy" for i in tqdm(range(len(tics))): - slc = search_lightcurve('TIC'+str(tics[i]), - mission='TESS', - exptime=120, - sector=[1,2], - author='SPOC') - + slc = search_lightcurve( + "TIC" + str(tics[i]), + mission="TESS", + exptime=120, + sector=[1, 2], + author="SPOC", + ) if len(slc) > 0: lcs = slc.download_all(download_dir=self.fn_dir) @@ -108,22 +109,23 @@ def download_lightcurves(self, remove_fits=True): # Default lightkurve flux = pdcsap_flux lc = lcs[j].normalize() - np.save(os.path.join(self.fn_dir, npy_name.format(tics[i], lc.sector)), - np.array([lc.time.value, - lc.flux.value, - lc.flux_err.value])) + np.save( + os.path.join(self.fn_dir, npy_name.format(tics[i], lc.sector)), + np.array([lc.time.value, lc.flux.value, lc.flux_err.value]), + ) # Removes FITS files when done if remove_fits == True: - for dp, dn, fn in os.walk(os.path.join(self.fn_dir, 'mastDownload')): - for file in [f for f in fn if f.endswith('.fits')]: + for dp, dn, fn in os.walk( + os.path.join(self.fn_dir, "mastDownload") + ): + for file in [f for f in fn if f.endswith(".fits")]: os.remove(os.path.join(dp, file)) os.rmdir(dp) - if remove_fits == True: - os.rmdir(os.path.join(self.fn_dir, 'mastDownload/TESS')) - os.rmdir(os.path.join(self.fn_dir, 'mastDownload')) + os.rmdir(os.path.join(self.fn_dir, "mastDownload/TESS")) + os.rmdir(os.path.join(self.fn_dir, "mastDownload")) def download_models(self, all_models=False): """ @@ -144,23 +146,26 @@ def download_models(self, all_models=False): models : np.array Array of model filenames. """ - hlsp_path = 'http://archive.stsci.edu/hlsps/stella/hlsp_stella_tess_ensemblemodel_all_tess_v0.1.0_bundle.tar.gz' + hlsp_path = "http://archive.stsci.edu/hlsps/stella/hlsp_stella_tess_ensemblemodel_all_tess_v0.1.0_bundle.tar.gz" - new_path = os.path.join(self.fn_dir, 'models') + new_path = os.path.join(self.fn_dir, "models") if os.path.isdir(new_path) == False: os.mkdir(new_path) if len(os.listdir(new_path)) == 100: - print('Models have already been downloaded to ~/.stella/models') + print("Models have already been downloaded to ~/.stella/models") else: - os.system('cd {0} && curl -O -L {1}'.format(self.fn_dir, hlsp_path)) - tarball = [os.path.join(self.fn_dir, i) for i in os.listdir(self.fn_dir) if i.endswith('tar.gz')][0] - os.system('cd {0} && tar -xzvf {1}'.format(self.fn_dir, tarball)) - - os.system('cd {0} && mv *.h5 {1}'.format(self.fn_dir, new_path)) - + os.system("cd {0} && curl -O -L {1}".format(self.fn_dir, hlsp_path)) + tarball = [ + os.path.join(self.fn_dir, i) + for i in os.listdir(self.fn_dir) + if i.endswith("tar.gz") + ][0] + os.system("cd {0} && tar -xzvf {1}".format(self.fn_dir, tarball)) + + os.system("cd {0} && mv *.h5 {1}".format(self.fn_dir, new_path)) self.model_dir = new_path models = np.sort([os.path.join(new_path, i) for i in os.listdir(new_path)]) diff --git a/stella/mark_flares.py b/stella/mark_flares.py index 8a04c4f..abd1cff 100644 --- a/stella/mark_flares.py +++ b/stella/mark_flares.py @@ -1,5 +1,21 @@ import numpy as np -from tqdm import tqdm +try: + from rich.progress import ( + Progress, + SpinnerColumn, + BarColumn, + TimeRemainingColumn, + MofNCompleteColumn, + TextColumn, + track, + ) + HAVE_RICH = True +except Exception: # pragma: no cover + HAVE_RICH = False +try: + from tqdm.rich import tqdm +except Exception: # pragma: no cover + from tqdm.auto import tqdm import more_itertools as mit from astropy import units as u from astropy.table import Table @@ -10,7 +26,7 @@ from .utils import * -__all__ = ['FitFlares'] +__all__ = ["FitFlares"] class FitFlares(object): @@ -26,7 +42,7 @@ def __init__(self, id, time, flux, flux_err, predictions): Uses the times, fluxes, and predictions defined in stella.ConvNN to identify and fit flares, as well as do injection-recovery for completeness. - + Parameters ---------- time : np.array @@ -38,7 +54,7 @@ def __init__(self, id, time, flux, flux_err, predictions): predictions : np.array Array of predictions for each light curve passed in. - + Attributes ---------- ids : np.array @@ -47,13 +63,12 @@ def __init__(self, id, time, flux, flux_err, predictions): flux_err : np.ndarray predictions : np.ndarray """ - self.IDs = id - self.time = time - self.flux = flux - self.flux_err = flux_err + self.IDs = id + self.time = time + self.flux = flux + self.flux_err = flux_err self.predictions = predictions - def group_inds(self, values): """ Groups regions marked as flares (> prob_threshold) for @@ -74,7 +89,7 @@ def group_inds(self, values): temp = [v] else: # SETS 4 CADENCE LIMIT - if (np.abs(v-maxi) <= 3): + if np.abs(v - maxi) <= 3: temp.append(v) if v > maxi: maxi = v @@ -84,18 +99,17 @@ def group_inds(self, values): results.append(temp) mini = maxi = v temp = [v] - + # GETS THE LAST GROUP - if i == len(values)-1: + if i == len(values) - 1: results.append(temp) - return np.array(results) - + # Ensure a ragged array of index groups is returned safely under NumPy>=1.24 + return np.array(results, dtype=object) - def get_init_guesses(self, groupings, time, flux, err, prob, - maskregion, region): + def get_init_guesses(self, groupings, time, flux, err, prob, maskregion, region): """ - Guesses at the initial t0 and amplitude based on + Guesses at the initial t0 and amplitude based on probability groups. Parameters @@ -115,48 +129,47 @@ def get_init_guesses(self, groupings, time, flux, err, prob, Array of amplitudes at each tpeak. """ tpeaks = np.array([]) - ampls = np.array([]) + ampls = np.array([]) if len(groupings) > 0: for g in groupings: - if g[0]-region < 0: - subreg = np.arange(0, g[-1]+region, 1, dtype=int) - elif g[-1]+region > len(time): - subreg = np.arange(len(time)-region, len(time), 1, dtype=int) + if g[0] - region < 0: + subreg = np.arange(0, g[-1] + region, 1, dtype=int) + elif g[-1] + region > len(time): + subreg = np.arange(len(time) - region, len(time), 1, dtype=int) else: - subreg = np.arange(g[0]-region, g[-1]+region, 1, dtype=int) + subreg = np.arange(g[0] - region, g[-1] + region, 1, dtype=int) - # LOOKS AT REGION AROUND FLARE - subt = time[subreg]+0.0 - subf = flux[subreg]+0.0 - sube = err[subreg]+0.0 - subp = prob[subreg]+0.0 + # LOOKS AT REGION AROUND FLARE + subt = time[subreg] + 0.0 + subf = flux[subreg] + 0.0 + sube = err[subreg] + 0.0 + subp = prob[subreg] + 0.0 - doubcheck = np.where(subp>=self.threshold)[0] + doubcheck = np.where(subp >= self.threshold)[0] - # FINDS HIGHEST "PROBABILITY" IN FLARE + # FINDS HIGHEST "PROBABILITY" IN FLARE if len(doubcheck) > 1: peak = np.argmax(subf[doubcheck]) - t0 = subt[doubcheck[peak]] - amp = subf[doubcheck[peak]] - + t0 = subt[doubcheck[peak]] + amp = subf[doubcheck[peak]] + else: - t0 = subt[doubcheck] + t0 = subt[doubcheck] amp = subf[doubcheck] - tpeaks = np.append(tpeaks, t0) - ampls = np.append(ampls, amp) + tpeaks = np.append(tpeaks, t0) + ampls = np.append(ampls, amp) return tpeaks, ampls - def identify_flare_peaks(self, threshold=0.5): """ Finds where the predicted value is above the threshold as a flare candidate. Groups consecutive indices as one flaring event. - + Parameters ---------- threshold : float, optional @@ -173,105 +186,287 @@ def identify_flare_peaks(self, threshold=0.5): self.threshold = threshold def chiSquare(var, x, y, yerr, t0_ind): - """ Chi-square fit for flare parameters. """ + """Chi-square fit for flare parameters.""" amp, rise, decay = var m, p = flare_lightcurve(x, t0_ind, amp, rise, decay) - return np.sum( (y-m)**2.0 / yerr**2.0 ) - + return np.sum((y - m) ** 2.0 / yerr**2.0) - table = Table(names=['Target_ID', 'tpeak', 'amp', 'ed_s', - 'rise', 'fall', 'prob']) - kernel_size = 15 + table = Table( + names=["Target_ID", "tpeak", "amp", "ed_s", "rise", "fall", "prob"] + ) + kernel_size = 15 kernel_size1 = 21 - for i in tqdm(range(len(self.IDs)), desc='Finding & Fitting Flares'): - time = self.time[i]+0.0 - flux = self.flux[i]+0.0 - err = self.flux_err[i]+0.0 - prob = self.predictions[i]+0.0 - - where_prob_higher = np.where(prob >= threshold)[0] - groupings = self.group_inds(where_prob_higher) - - tpeaks, amps = self.get_init_guesses(groupings, time, flux, - err, prob, 2, 50) - - - # FITS PARAMETERS TO FLARE - for tp, amp in zip(tpeaks,amps): - # CASES FOR HANDLING BIG FLARES - if amp > 1.3: - region = 400 - maskregion = 150 - else: - region = 40 - maskregion = 10 - - where = np.where(time >= tp)[0][0] - - subt = time[where-region:where+region] - subf = flux[where-region:where+region] - sube = err[ where-region:where+region] - subp = prob[where-region:where+region] - amp_ind = int(len(subf)/2) - - mask = np.zeros(len(subt)) - mask[int(amp_ind-maskregion/2.):int(amp_ind+maskregion)] = 1 - m = mask == 0 - - if len(mask) > 10: - func = interp1d(subt[m], medfilt(subf[m], kernel_size=kernel_size)) - func1 = interp1d(subt, medfilt(subf, kernel_size=kernel_size1)) - # REMOVES LOCAL STELLAR VARIABILITY TO FIT FLARE - detrended = subf/func(subt) - std = np.nanstd(detrended[m]) - med = np.nanmedian(detrended[m]) - - detrend_with_flare = subf/func1(subt) - std1 = np.nanstd(detrend_with_flare) - med1 = np.nanmedian(detrend_with_flare) - - amp = subf[amp_ind] - amp1 = detrended[amp_ind] - - if amp > 1.5: - decay_guess = 0.008 - rise_guess = 0.003 - else: - decay_guess = 0.001 - rise_guess = 0.0001 - - # Checks if amplitude of flare is 1.5sig, and the next 2 consecutive points < amp - if ( (amp1 > (med+1.5*std) ) and (subf[amp_ind+1] <= amp) and (subf[amp_ind+2] <= amp) and - (subf[amp_ind-1] <= amp)): - - # Checks if next 2 consecutive points are > 1sig above - if (detrended[amp_ind+1] >= (med1+std1)):# and (detrended[amp_ind+2] >= (med1+std1)): - - # Checks if point before amp < amp and that it isn't catching noise - if (subf[amp_ind-1] < amp) and ((amp-subf[-1]) < 2): - - amp1 -= med - - x = minimize(chiSquare, x0=[amp1, rise_guess, decay_guess], - bounds=((amp1-0.1,amp1+0.1), (0.0001,0.01), - (0.0005, 0.01)), - args=(subt[int(len(subt)/2-maskregion):int(len(subt)/2+maskregion)], - detrended[int(len(detrended)/2-maskregion):int(len(detrended)/2+maskregion)], - sube[int(len(sube)/2-maskregion):int(len(sube)/2+maskregion)], - int(len(subt[int(len(subt)/2-maskregion):int(len(subt)/2+maskregion)])/2)), - method='L-BFGS-B') - - if x.x[0] > 1.5 or (x.x[0]<1.5 and x.x[2]<0.4): - fm, params = flare_lightcurve(subt, amp_ind, np.nanmedian([amp1, x.x[0]]), - x.x[1], x.x[2]) - dur = np.trapz(fm-1, subt) * u.day - params[1] = detrended[amp_ind] - params[2] = dur.to(u.s).value - params = np.append(params, subp[amp_ind]) - params = np.append(np.array([self.IDs[i]]), params) - - table.add_row(params) - - - self.flare_table = table[table['amp'] > 1.002] + total_targets = len(self.IDs) + def _tqdm_args(**kwargs): + mod = getattr(tqdm, "__module__", "") + if mod.startswith("tqdm.rich"): + kwargs.pop("position", None) + kwargs.pop("dynamic_ncols", None) + return kwargs + + if HAVE_RICH: + for i in track(range(total_targets), description="Finding & Fitting Flares"): + # Ensure numeric arrays (avoid object dtype from ragged wrappers) + time = np.asarray(self.time[i], dtype=float) + flux = np.asarray(self.flux[i], dtype=float) + err = np.asarray(self.flux_err[i], dtype=float) + prob = np.asarray(self.predictions[i], dtype=float) + + where_prob_higher = np.where(prob >= threshold)[0] + groupings = self.group_inds(where_prob_higher) + + tpeaks, amps = self.get_init_guesses( + groupings, time, flux, err, prob, 2, 50 + ) + + # FITS PARAMETERS TO FLARE + for tp, amp in zip(tpeaks, amps): + # CASES FOR HANDLING BIG FLARES + if amp > 1.3: + region = 400 + maskregion = 150 + else: + region = 40 + maskregion = 10 + + where = np.where(time >= tp)[0][0] + + subt = time[where - region : where + region] + subf = flux[where - region : where + region] + sube = err[where - region : where + region] + subp = prob[where - region : where + region] + amp_ind = int(len(subf) / 2) + + mask = np.zeros(len(subt)) + mask[int(amp_ind - maskregion / 2.0) : int(amp_ind + maskregion)] = 1 + m = mask == 0 + + if len(mask) > 10: + func = interp1d(subt[m], medfilt(subf[m], kernel_size=kernel_size)) + func1 = interp1d(subt, medfilt(subf, kernel_size=kernel_size1)) + # REMOVES LOCAL STELLAR VARIABILITY TO FIT FLARE + detrended = subf / func(subt) + std = np.nanstd(detrended[m]) + med = np.nanmedian(detrended[m]) + + detrend_with_flare = subf / func1(subt) + std1 = np.nanstd(detrend_with_flare) + med1 = np.nanmedian(detrend_with_flare) + + amp = subf[amp_ind] + amp1 = detrended[amp_ind] + + if amp > 1.5: + decay_guess = 0.008 + rise_guess = 0.003 + else: + decay_guess = 0.001 + rise_guess = 0.0001 + + # Checks if amplitude of flare is 1.5sig, and the next 2 consecutive points < amp + if ( + (amp1 > (med + 1.5 * std)) + and (subf[amp_ind + 1] <= amp) + and (subf[amp_ind + 2] <= amp) + and (subf[amp_ind - 1] <= amp) + ): + + # Checks if next 2 consecutive points are > 1sig above + if detrended[amp_ind + 1] >= ( + med1 + std1 + ): # and (detrended[amp_ind+2] >= (med1+std1)): + + # Checks if point before amp < amp and that it isn't catching noise + if (subf[amp_ind - 1] < amp) and ((amp - subf[-1]) < 2): + + amp1 -= med + + x = minimize( + chiSquare, + x0=[amp1, rise_guess, decay_guess], + bounds=( + (amp1 - 0.1, amp1 + 0.1), + (0.0001, 0.01), + (0.0005, 0.01), + ), + args=( + subt[ + int(len(subt) / 2 - maskregion) : int( + len(subt) / 2 + maskregion + ) + ], + detrended[ + int(len(detrended) / 2 - maskregion) : int( + len(detrended) / 2 + maskregion + ) + ], + sube[ + int(len(sube) / 2 - maskregion) : int( + len(sube) / 2 + maskregion + ) + ], + int( + len( + subt[ + int( + len(subt) / 2 - maskregion + ) : int(len(subt) / 2 + maskregion) + ] + ) + / 2 + ), + ), + method="L-BFGS-B", + ) + + if x.x[0] > 1.5 or (x.x[0] < 1.5 and x.x[2] < 0.4): + fm, params = flare_lightcurve( + subt, + amp_ind, + np.nanmedian([amp1, x.x[0]]), + x.x[1], + x.x[2], + ) + dur = np.trapz(fm - 1, subt) * u.day + params[1] = detrended[amp_ind] + params[2] = dur.to(u.s).value + params = np.append(params, subp[amp_ind]) + params = np.append(np.array([self.IDs[i]]), params) + + table.add_row(params) + else: + # Use tqdm context manager instead of try/finally + with tqdm(total=total_targets, desc="Finding & Fitting Flares", **_tqdm_args(dynamic_ncols=True, leave=True)) as pbar: + for i in range(total_targets): + # Ensure numeric arrays (avoid object dtype from ragged wrappers) + time = np.asarray(self.time[i], dtype=float) + flux = np.asarray(self.flux[i], dtype=float) + err = np.asarray(self.flux_err[i], dtype=float) + prob = np.asarray(self.predictions[i], dtype=float) + + where_prob_higher = np.where(prob >= threshold)[0] + groupings = self.group_inds(where_prob_higher) + + tpeaks, amps = self.get_init_guesses( + groupings, time, flux, err, prob, 2, 50 + ) + + # FITS PARAMETERS TO FLARE + for tp, amp in zip(tpeaks, amps): + # CASES FOR HANDLING BIG FLARES + if amp > 1.3: + region = 400 + maskregion = 150 + else: + region = 40 + maskregion = 10 + + where = np.where(time >= tp)[0][0] + + subt = time[where - region : where + region] + subf = flux[where - region : where + region] + sube = err[where - region : where + region] + subp = prob[where - region : where + region] + amp_ind = int(len(subf) / 2) + + mask = np.zeros(len(subt)) + mask[int(amp_ind - maskregion / 2.0) : int(amp_ind + maskregion)] = 1 + m = mask == 0 + + if len(mask) > 10: + func = interp1d(subt[m], medfilt(subf[m], kernel_size=kernel_size)) + func1 = interp1d(subt, medfilt(subf, kernel_size=kernel_size1)) + # REMOVES LOCAL STELLAR VARIABILITY TO FIT FLARE + detrended = subf / func(subt) + std = np.nanstd(detrended[m]) + med = np.nanmedian(detrended[m]) + + detrend_with_flare = subf / func1(subt) + std1 = np.nanstd(detrend_with_flare) + med1 = np.nanmedian(detrend_with_flare) + + amp = subf[amp_ind] + amp1 = detrended[amp_ind] + + if amp > 1.5: + decay_guess = 0.008 + rise_guess = 0.003 + else: + decay_guess = 0.001 + rise_guess = 0.0001 + + # Checks if amplitude of flare is 1.5sig, and the next 2 consecutive points < amp + if ( + (amp1 > (med + 1.5 * std)) + and (subf[amp_ind + 1] <= amp) + and (subf[amp_ind + 2] <= amp) + and (subf[amp_ind - 1] <= amp) + ): + + # Checks if next 2 consecutive points are > 1sig above + if detrended[amp_ind + 1] >= ( + med1 + std1 + ): # and (detrended[amp_ind+2] >= (med1+std1)): + + # Checks if point before amp < amp and that it isn't catching noise + if (subf[amp_ind - 1] < amp) and ((amp - subf[-1]) < 2): + + amp1 -= med + + x = minimize( + chiSquare, + x0=[amp1, rise_guess, decay_guess], + bounds=( + (amp1 - 0.1, amp1 + 0.1), + (0.0001, 0.01), + (0.0005, 0.01), + ), + args=( + subt[ + int(len(subt) / 2 - maskregion) : int( + len(subt) / 2 + maskregion + ) + ], + detrended[ + int(len(detrended) / 2 - maskregion) : int( + len(detrended) / 2 + maskregion + ) + ], + sube[ + int(len(sube) / 2 - maskregion) : int( + len(sube) / 2 + maskregion + ) + ], + int( + len( + subt[ + int( + len(subt) / 2 - maskregion + ) : int(len(subt) / 2 + maskregion) + ] + ) + / 2 + ), + ), + method="L-BFGS-B", + ) + + if x.x[0] > 1.5 or (x.x[0] < 1.5 and x.x[2] < 0.4): + fm, params = flare_lightcurve( + subt, + amp_ind, + np.nanmedian([amp1, x.x[0]]), + x.x[1], + x.x[2], + ) + dur = np.trapz(fm - 1, subt) * u.day + params[1] = detrended[amp_ind] + params[2] = dur.to(u.s).value + params = np.append(params, subp[amp_ind]) + params = np.append(np.array([self.IDs[i]]), params) + + table.add_row(params) + pbar.update(1) + + self.flare_table = table[table["amp"] > 1.002] diff --git a/stella/metrics.py b/stella/metrics.py index d228b7e..064365a 100644 --- a/stella/metrics.py +++ b/stella/metrics.py @@ -7,7 +7,7 @@ from sklearn.metrics import precision_recall_curve from sklearn.metrics import average_precision_score -__all__ = ['ModelMetrics'] +__all__ = ["ModelMetrics"] class ModelMetrics(object): @@ -16,7 +16,7 @@ class ModelMetrics(object): or cross validation. """ - def __init__(self, fn_dir, mode='ensemble'): + def __init__(self, fn_dir, mode="ensemble"): """ Initializes class. Requires a directory where all of the files from the same model runs are saved @@ -25,22 +25,21 @@ def __init__(self, fn_dir, mode='ensemble'): fn_dir : str Path to where all of the tables are saved. mode : str, optional - Sets which models to calculate metrics for. Default is + Sets which models to calculate metrics for. Default is 'ensemble'. Other option is 'cross_val' for cross validation models. """ - self.dir = fn_dir - self.mode = mode + self.dir = fn_dir + self.mode = mode self.load_data() - if mode == 'ensemble': + if mode == "ensemble": self.ensemble_average() - def load_data(self): """ - Pareses file names in fn_dir for the seed, number of epochs, + Pareses file names in fn_dir for the seed, number of epochs, fractional balance, and fold (for cross validation). Attributes ---------- @@ -52,93 +51,92 @@ def load_data(self): """ df = os.listdir(self.dir) - if self.mode == 'cross_val': - files = np.sort([i for i in df if 'crossval' in i]) + if self.mode == "cross_val": + files = np.sort([i for i in df if "crossval" in i]) folds = [] - elif self.mode == 'ensemble': - files = np.sort([i for i in df if 'ensemble' in i]) + elif self.mode == "ensemble": + files = np.sort([i for i in df if "ensemble" in i]) seeds = [] - self.models = [i for i in files if i.endswith('.h5')] + self.models = [i for i in files if i.endswith(".keras")] - predval = [i for i in files if 'predval' in i][0] - history = [i for i in files if 'histories' in i][0] + predval = [i for i in files if "predval" in i][0] + history = [i for i in files if "histories" in i][0] try: - predtest = [i for i in files if 'predtest' in i][0] - self.predtest_table = Table.read(os.path.join(self.dir, predtest), - format='ascii') + predtest = [i for i in files if "predtest" in i][0] + self.predtest_table = Table.read( + os.path.join(self.dir, predtest), format="ascii" + ) except: self.predtest_table = None print("No predictions on test set available.") - parsing = self.models[0].split('_') - self.seeds = int(parsing[1].split('s')[1]) - self.epochs = int(parsing[2].split('i')[1]) - self.frac_balance = float(parsing[3].split('b')[1][0:4]) - + parsing = self.models[0].split("_") + self.seeds = int(parsing[1].split("s")[1]) + self.epochs = int(parsing[2].split("i")[1]) + self.frac_balance = float(parsing[3].split("b")[1][0:4]) + for m in self.models: - if self.mode == 'cross_val': - f = int(m.split('_')[4].split('.')[0][1:]) + if self.mode == "cross_val": + f = int(m.split("_")[4].split(".")[0][1:]) folds.append(f) self.folds = folds - if self.mode == 'ensemble': - s = int(m.split('_')[1].split('s')[1]) + if self.mode == "ensemble": + s = int(m.split("_")[1].split("s")[1]) seeds.append(s) self.seeds = seeds - self.predval_table = Table.read(os.path.join(self.dir, predval), format='ascii') - self.history_table = Table.read(os.path.join(self.dir, history), format='ascii') - + self.predval_table = Table.read(os.path.join(self.dir, predval), format="ascii") + self.history_table = Table.read(os.path.join(self.dir, history), format="ascii") def ensemble_average(self): """ - Creates an average prediction column in the predval and predtest + Creates an average prediction column in the predval and predtest tables if mode = 'ensemble' and there is more than 1 model to evaluate. Else, the average prediction column is the same as the prediction column in the table. """ mean_arr = [] - - colnames = [i for i in self.predval_table.colnames if 'pred' in i] + + colnames = [i for i in self.predval_table.colnames if "pred" in i] for cn in colnames: mean_arr.append(np.round(self.predval_table[cn].data, 3)) - self.predval_table.add_column(Column(np.nanmean(mean_arr, axis=0), - name='pred_mean')) + self.predval_table.add_column( + Column(np.nanmean(mean_arr, axis=0), name="pred_mean") + ) if self.predtest_table is not None: mean_arr = [] - colnames = [i for i in self.predtest_table.colnames if 'pred' in i] + colnames = [i for i in self.predtest_table.colnames if "pred" in i] for cn in colnames: mean_arr.append(np.round(self.predtest_table[cn].data, 3)) - self.predtest_table.add_column(Column(np.nanmean(mean_arr, axis=0), - name='pred_mean')) - + self.predtest_table.add_column( + Column(np.nanmean(mean_arr, axis=0), name="pred_mean") + ) def pred_round(self, table, threshold): - """ Rounds the average prediction based on a threshold. """ + """Rounds the average prediction based on a threshold.""" pr = np.zeros(len(table)) - pr[table['pred_mean'].data >= threshold] = 1 - pr[table['pred_mean'].data < threshold] = 0 - table.add_column(Column(pr, name='round_pred'), index=3) + pr[table["pred_mean"].data >= threshold] = 1 + pr[table["pred_mean"].data < threshold] = 0 + table.add_column(Column(pr, name="round_pred"), index=3) return table - def set_table(self, data_set): - """ Sets table for metric calculation.""" - if data_set == 'validation': + """Sets table for metric calculation.""" + if data_set == "validation": table = self.predval_table - elif data_set == 'test': + elif data_set == "test": if self.predtest_table is not None: table = self.predtest_table else: raise ValueError("No test set predictions found.") return table - - def calculate_ensemble_metrics(self, threshold=0.5, data_set='validation'): + def calculate_ensemble_metrics(self, threshold=0.5, data_set="validation"): """ Calculates average precision, accuracy, recall, and precision-recall curve for flares above a given threshold value. @@ -169,38 +167,42 @@ def calculate_ensemble_metrics(self, threshold=0.5, data_set='validation'): ap, ac, rs, ps = [], [], [], [] p_cur, r_cur = [], [] - gt = tab['gt'].data - - keys = np.sort([i for i in tab.colnames if 'pred_' in i]) + gt = tab["gt"].data + + keys = np.sort([i for i in tab.colnames if "pred_" in i]) for i, val in enumerate(keys): - ap.append( np.round(average_precision_score(gt, tab[val].data, - average=None), 4)) + ap.append( + np.round(average_precision_score(gt, tab[val].data, average=None), 4) + ) arr = np.copy(tab[val].data) arr[arr >= threshold] = 1.0 - arr[arr < threshold] = 0.0 + arr[arr < threshold] = 0.0 - ac.append( np.round(np.sum(arr == gt) / len(tab), 4)) + ac.append(np.round(np.sum(arr == gt) / len(tab), 4)) - prec, rec, _ = precision_recall_curve(gt, tab['pred_mean'].data) + prec, rec, _ = precision_recall_curve(gt, tab["pred_mean"].data) - ind = keys == 'pred_mean' + ind = keys == "pred_mean" self.ensemble_avg_precision = ap[0] self.ensemble_accuracy = ac[0] - self.ensemble_recall_score = np.round(recall_score(gt, tab['round_pred'].data), 4) - self.ensemble_precision_score = np.round(precision_score(gt, tab['round_pred'].data), 4) + self.ensemble_recall_score = np.round( + recall_score(gt, tab["round_pred"].data), 4 + ) + self.ensemble_precision_score = np.round( + precision_score(gt, tab["round_pred"].data), 4 + ) self.ensemble_curve = np.array([rec, prec]) - if data_set == 'validation': + if data_set == "validation": self.predval_table = tab else: self.predtest_table = tab - - def calculate_cross_val_metrics(self, threshold=0.5, data_set='validation'): + def calculate_cross_val_metrics(self, threshold=0.5, data_set="validation"): """ Calculates average precision, accuracy, recall, and precision-recall curve for flares above a given threshold value. - + Parameters ---------- threshold : float, optional @@ -225,34 +227,40 @@ def calculate_cross_val_metrics(self, threshold=0.5, data_set='validation'): ap, ac, rs, ps = [], [], [], [] p_cur, r_cur = [], [] - keys = np.sort([i for i in tab.colnames if 'pred_f' in i]) + keys = np.sort([i for i in tab.colnames if "pred_f" in i]) for i, val in enumerate(keys): - gt_key = 'gt_' + val.split('_')[1] + gt_key = "gt_" + val.split("_")[1] # ROUNDED BASED ON THRESHOLD arr = np.copy(tab[val].data) arr[arr >= threshold] = 1.0 - arr[arr < threshold] = 0.0 + arr[arr < threshold] = 0.0 ac.append(np.round(np.sum(arr == tab[gt_key].data) / len(tab), 4)) - - ap.append(np.round(average_precision_score(tab[gt_key].data, - tab[val].data, - average=None), 4)) - + + ap.append( + np.round( + average_precision_score( + tab[gt_key].data, tab[val].data, average=None + ), + 4, + ) + ) + # CALCULATES RECALL SCORE - rs.append( np.round( recall_score(tab[gt_key].data, arr), 4)) - + rs.append(np.round(recall_score(tab[gt_key].data, arr), 4)) + # CALCULATES PRECISION SCORE - ps.append( np.round( precision_score(tab[gt_key].data, arr), 4)) + ps.append(np.round(precision_score(tab[gt_key].data, arr), 4)) # CREATES PRECISION RECALL CURVE - prec_curve, rec_curve, _ = precision_recall_curve(tab[gt_key].data, tab[val].data) + prec_curve, rec_curve, _ = precision_recall_curve( + tab[gt_key].data, tab[val].data + ) p_cur.append(prec_curve) r_cur.append(rec_curve) - self.cross_val_avg_precision = ap self.cross_val_accuracy = ac @@ -260,14 +268,14 @@ def calculate_cross_val_metrics(self, threshold=0.5, data_set='validation'): self.cross_val_precision_score = ps self.cross_val_curve = np.array([r_cur, p_cur]) - if data_set == 'validation': + if data_set == "validation": self.predval_table = tab else: self.predtest_table = tab - - def confusion_matrix(self, ds, threshold=0.5, colormap='inferno', - data_set='validation'): + def confusion_matrix( + self, ds, threshold=0.5, colormap="inferno", data_set="validation" + ): """ Plots the confusion matrix of true positives, true negatives, false positives, and false @@ -286,7 +294,7 @@ def confusion_matrix(self, ds, threshold=0.5, colormap='inferno', data_set : str, optional Sets which data set to look at. Default is 'validation'. Other option is 'test'. DO NOT LOOK AT THE TEST SET UNTIL - YOU ARE COMPLETELY HAPPY WITH YOUR MODEL. + YOU ARE COMPLETELY HAPPY WITH YOUR MODEL. """ # GETS THE COLORS FOR PLOTTING cmap = cm.get_cmap(colormap, 15) @@ -298,11 +306,10 @@ def confusion_matrix(self, ds, threshold=0.5, colormap='inferno', # PLOTTING NORMALIZED LIGHT CURVE TO GIVEN SUBPLOT def plot_lc(data, ind, ax, color, offset): - """ Plots the light curve on a given axis. """ - ax.set_xlim(0,200) - ax.set_ylim(-3,3.5) - ax.axvline(100, linestyle='dotted', color='gray', - linewidth=0.5) + """Plots the light curve on a given axis.""" + ax.set_xlim(0, 200) + ax.set_ylim(-3, 3.5) + ax.axvline(100, linestyle="dotted", color="gray", linewidth=0.5) ax.set_yticks([]) ax.set_xticks([]) @@ -315,47 +322,49 @@ def plot_lc(data, ind, ax, color, offset): return ax # GETS THE TABLE & VALIDATION DATA FOR THE MATRIX - if data_set == 'validation': + if data_set == "validation": df = self.predval_table x_val = ds.val_data - elif data_set == 'test': + elif data_set == "test": df = self.predtest_table x_val = ds.test_data try: - df['round_pred'] + df["round_pred"] except: df = self.pred_round(df, threshold) # INDICES FOR THE CONFUSION MATRIX - ind_tn = np.where( (df['round_pred'] == 0) & (df['gt'] == 0) )[0] - ind_fn = np.where( (df['round_pred'] == 0) & (df['gt'] == 1) )[0] - ind_tp = np.where( (df['round_pred'] == 1) & (df['gt'] == 1) )[0] - ind_fp = np.where( (df['round_pred'] == 1) & (df['gt'] == 0) )[0] + ind_tn = np.where((df["round_pred"] == 0) & (df["gt"] == 0))[0] + ind_fn = np.where((df["round_pred"] == 0) & (df["gt"] == 1))[0] + ind_tp = np.where((df["round_pred"] == 1) & (df["gt"] == 1))[0] + ind_fp = np.where((df["round_pred"] == 1) & (df["gt"] == 0))[0] order = [ind_tn, ind_fp, ind_fn, ind_tp] - titles = ['True Negatives', 'False Positives', - 'False Negatives', 'True Positives'] + titles = [ + "True Negatives", + "False Positives", + "False Negatives", + "True Positives", + ] shifts = [-2, 0, 2] - fig, axes = plt.subplots(ncols=2, nrows=2, figsize=(10,8)) + fig, axes = plt.subplots(ncols=2, nrows=2, figsize=(10, 8)) i = 0 for ax in axes.reshape(-1): inds = order[i] - which = np.random.randint(0,len(inds),3) + which = np.random.randint(0, len(inds), 3) for j in range(3): - ax = plot_lc(x_val, inds[which[j]], ax, colors[j*2+1], - shifts[j]) + ax = plot_lc(x_val, inds[which[j]], ax, colors[j * 2 + 1], shifts[j]) ax.set_title(titles[i], fontsize=20) - if titles[i] == 'False Positives' or titles[i] == 'False Negatives': - ax.set_facecolor('lightgray') + if titles[i] == "False Positives" or titles[i] == "False Negatives": + ax.set_facecolor("lightgray") i += 1 return fig - diff --git a/stella/models.py b/stella/models.py new file mode 100644 index 0000000..a821b07 --- /dev/null +++ b/stella/models.py @@ -0,0 +1,33 @@ +from __future__ import annotations + +from importlib import resources as _resources +from typing import List, Optional + +DEFAULT_MODEL_NAME = "ensemble_s0018_i0350_b0.73_savedmodel.keras" + + +def list_model_names() -> List[str]: + """Return the list of packaged model filenames.""" + data = _resources.files("stella.data") + return sorted([p.name for p in data.iterdir() if p.suffix == ".keras"]) # type: ignore[attr-defined] + + +def list_model_paths() -> List[str]: + """Return absolute paths to all packaged models.""" + data = _resources.files("stella.data") + return sorted([str(p) for p in data.iterdir() if p.suffix == ".keras"]) # type: ignore[attr-defined] + + +def get_model_path(name: Optional[str] = None) -> str: + """Return the absolute path to a packaged model by name. + + If `name` is None, returns the default model path. + """ + if name is None: + name = DEFAULT_MODEL_NAME + return str(_resources.files("stella.data") / name) + + +# Convenience precomputed list of model paths for notebooks and quickstarts +# Equivalent to calling list_model_paths(). +models: List[str] = list_model_paths() diff --git a/stella/neural_network.py b/stella/neural_network.py index 92b41f8..0185036 100755 --- a/stella/neural_network.py +++ b/stella/neural_network.py @@ -1,12 +1,31 @@ import os, glob +import warnings import numpy as np -from tqdm import tqdm -import tensorflow as tf -from tensorflow import keras +try: + from rich.progress import ( + Progress, + SpinnerColumn, + BarColumn, + TimeRemainingColumn, + MofNCompleteColumn, + TextColumn, + track, + ) + HAVE_RICH = True +except Exception: # pragma: no cover + HAVE_RICH = False +try: + from tqdm.rich import tqdm +except Exception: # pragma: no cover + from tqdm.auto import tqdm +from .backends import require_backend as _require_backend +_require_backend() +import keras from scipy.interpolate import interp1d from astropy.table import Table, Column -__all__ = ['ConvNN'] +__all__ = ["ConvNN"] + class ConvNN(object): """ @@ -14,15 +33,20 @@ class ConvNN(object): neural network. """ - def __init__(self, output_dir, ds=None, - layers=None, optimizer='adam', - loss='binary_crossentropy', - metrics=None): + def __init__( + self, + output_dir, + ds=None, + layers=None, + optimizer="adam", + loss="binary_crossentropy", + metrics=None, + ): """ - Creates and trains a Tensorflow keras model + Creates and trains a Keras model (JAX backend) with either layers that have been passed in by the user or with default layers used in - Feinstein et al. (2020; in prep.). + Feinstein et al. (2020), https://arxiv.org/abs/2005.07710. Parameters ---------- @@ -80,8 +104,8 @@ def __init__(self, output_dir, ds=None, self.training_ids = ds.training_ids else: - print("WARNING: No stella.DataSet object passed in.") - print("Can only use stella.ConvNN.predict().") + # Inference-only usage: defer warnings to training-time methods + pass self.prec_recall_curve = None self.history = None @@ -89,18 +113,24 @@ def __init__(self, output_dir, ds=None, self.output_dir = output_dir - def create_model(self, seed): """ - Creates the Tensorflow keras model with appropriate layers. - + Creates the Keras model with appropriate layers. + Attributes ---------- - model : tensorflow.python.keras.engine.sequential.Sequential + model : keras.models.Sequential """ + if getattr(self, "ds", None) is None: + warnings.warn( + "No stella.DataSet provided. Training requires ConvNN(ds=...). For inference, use predict()." + ) + raise ValueError( + "Training requires a stella.DataSet (ConvNN(ds=...)). For inference, use predict(modelname=..., ...)." + ) # SETS RANDOM SEED FOR REPRODUCABLE RESULTS np.random.seed(seed) - tf.random.set_seed(seed) + keras.utils.set_random_seed(seed) # INITIALIZE CLEAN MODEL keras.backend.clear_session() @@ -111,50 +141,59 @@ def create_model(self, seed): if self.layers is None: filter1 = 16 filter2 = 64 - dense = 32 + dense = 32 dropout = 0.1 # CONVOLUTIONAL LAYERS - model.add(tf.keras.layers.Conv1D(filters=filter1, kernel_size=7, - activation='relu', padding='same', - input_shape=(self.cadences, 1))) - model.add(tf.keras.layers.MaxPooling1D(pool_size=2)) - model.add(tf.keras.layers.Dropout(dropout)) - model.add(tf.keras.layers.Conv1D(filters=filter2, kernel_size=3, - activation='relu', padding='same')) - model.add(tf.keras.layers.MaxPooling1D(pool_size=2)) - model.add(tf.keras.layers.Dropout(dropout)) - + model.add( + keras.layers.Conv1D( + filters=filter1, + kernel_size=7, + activation="relu", + padding="same", + input_shape=(self.cadences, 1), + ) + ) + model.add(keras.layers.MaxPooling1D(pool_size=2)) + model.add(keras.layers.Dropout(dropout)) + model.add( + keras.layers.Conv1D( + filters=filter2, kernel_size=3, activation="relu", padding="same" + ) + ) + model.add(keras.layers.MaxPooling1D(pool_size=2)) + model.add(keras.layers.Dropout(dropout)) + # DENSE LAYERS AND SOFTMAX OUTPUT - model.add(tf.keras.layers.Flatten()) - model.add(tf.keras.layers.Dense(dense, activation='relu')) - model.add(tf.keras.layers.Dropout(dropout)) - model.add(tf.keras.layers.Dense(1, activation='sigmoid')) - + model.add(keras.layers.Flatten()) + model.add(keras.layers.Dense(dense, activation="relu")) + model.add(keras.layers.Dropout(dropout)) + model.add(keras.layers.Dense(1, activation="sigmoid")) + else: for l in self.layers: model.add(l) - + # COMPILE MODEL AND SET OPTIMIZER, LOSS, METRICS if self.metrics is None: - model.compile(optimizer=self.optimizer, - loss=self.loss, - metrics=['accuracy', tf.keras.metrics.Precision(), - tf.keras.metrics.Recall()]) + model.compile( + optimizer=self.optimizer, + loss=self.loss, + metrics=["accuracy", keras.metrics.Precision(), keras.metrics.Recall()], + ) else: - model.compile(optimizer=self.optimizer, - loss=self.loss, - metrics=self.metrics) + model.compile( + optimizer=self.optimizer, loss=self.loss, metrics=self.metrics + ) self.model = model # PRINTS MODEL SUMMARY model.summary() - - def load_model(self, modelname, mode='validation'): + def load_model(self, modelname, mode="validation"): """ - Loads an already created model. + Loads an already created model. Parameters ---------- @@ -163,23 +202,33 @@ def load_model(self, modelname, mode='validation'): """ model = keras.models.load_model(modelname) self.model = model - - if mode == 'test': + + if getattr(self, "ds", None) is None: + # No dataset attached; just load model for inference and return + return + + if mode == "test": pred = model.predict(self.ds.test_data) - elif mode == 'validation': + elif mode == "validation": pred = model.predict(self.ds.val_data) pred = np.reshape(pred, len(pred)) - - ## Calculate metrics from here - return - - def train_models(self, seeds=[2], epochs=350, batch_size=64, shuffle=False, - pred_test=False, save=False): + # Placeholder for metrics calculation + return + + def train_models( + self, + seeds=[2], + epochs=350, + batch_size=64, + shuffle=False, + pred_test=False, + save=False, + ): """ Runs n number of models with given initial random seeds of - length n. Also saves each model run to a hidden ~/.stella - directory. + length n. Also saves each model run to a hidden ~/.stella + directory. Parameters ---------- @@ -214,36 +263,55 @@ def train_models(self, seeds=[2], epochs=350, batch_size=64, shuffle=False, pred_test = True, or else it is an empty table. """ - if type(seeds) == int or type(seeds) == float or type(seeds) == np.int64: + if type(seeds) == int or type(seeds) == float or type(seeds) == np.int64: seeds = np.array([seeds]) + if getattr(self, "ds", None) is None: + warnings.warn( + "No stella.DataSet provided. Training requires ConvNN(ds=...). For inference, use predict()." + ) + raise ValueError( + "Training requires a stella.DataSet (ConvNN(ds=...)). For inference, use predict(modelname=..., ...)." + ) + self.epochs = epochs # CREATES TABLES FOR SAVING DATA table = Table() - val_table = Table([self.ds.val_ids, self.ds.val_labels, self.ds.val_tpeaks], - names=['tic', 'gt', 'tpeak']) - test_table = Table([self.ds.test_ids, self.ds.test_labels, self.ds.test_tpeaks], - names=['tic', 'gt', 'tpeak']) - - + val_table = Table( + [self.ds.val_ids, self.ds.val_labels, self.ds.val_tpeaks], + names=["tic", "gt", "tpeak"], + ) + test_table = Table( + [self.ds.test_ids, self.ds.test_labels, self.ds.test_tpeaks], + names=["tic", "gt", "tpeak"], + ) + for seed in seeds: - - fmt_tail = '_s{0:04d}_i{1:04d}_b{2}'.format(int(seed), int(epochs), self.frac_balance) - model_fmt = 'ensemble' + fmt_tail + '.h5' + + fmt_tail = "_s{0:04d}_i{1:04d}_b{2}".format( + int(seed), int(epochs), self.frac_balance + ) + model_fmt = "ensemble" + fmt_tail + ".keras" keras.backend.clear_session() - + # CREATES MODEL BASED ON GIVEN RANDOM SEED self.create_model(seed) - self.history = self.model.fit(self.ds.train_data, self.ds.train_labels, - epochs=epochs, - batch_size=batch_size, shuffle=shuffle, - validation_data=(self.ds.val_data, self.ds.val_labels)) + self.history = self.model.fit( + self.ds.train_data, + self.ds.train_labels, + epochs=epochs, + batch_size=batch_size, + shuffle=shuffle, + validation_data=(self.ds.val_data, self.ds.val_labels), + ) col_names = list(self.history.history.keys()) for cn in col_names: - col = Column(self.history.history[cn], name=cn+'_s{0:04d}'.format(int(seed))) + col = Column( + self.history.history[cn], name=cn + "_s{0:04d}".format(int(seed)) + ) table.add_column(col) # SAVES THE MODEL TO OUTPUT DIRECTORY @@ -252,15 +320,18 @@ def train_models(self, seeds=[2], epochs=350, batch_size=64, shuffle=False, # GETS PREDICTIONS FOR EACH VALIDATION SET LIGHT CURVE val_preds = self.model.predict(self.ds.val_data) val_preds = np.reshape(val_preds, len(val_preds)) - val_table.add_column(Column(val_preds, name='pred_s{0:04d}'.format(int(seed)))) - + val_table.add_column( + Column(val_preds, name="pred_s{0:04d}".format(int(seed))) + ) # GETS PREDICTIONS FOR EACH TEST SET LIGHT CURVE IF PRED_TEST IS TRUE if pred_test is True: test_preds = self.model.predict(self.ds.test_data) test_preds = np.reshape(test_preds, len(test_preds)) - test_table.add_column(Column(test_preds, name='pred_s{0:04d}'.format(int(seed)))) - + test_table.add_column( + Column(test_preds, name="pred_s{0:04d}".format(int(seed))) + ) + # SETS TABLE ATTRIBUTES self.history_table = table self.val_pred_table = val_table @@ -268,22 +339,35 @@ def train_models(self, seeds=[2], epochs=350, batch_size=64, shuffle=False, # SAVES TABLE IS SAVE IS TRUE if save is True: - fmt_table = '_i{0:04d}_b{1}.txt'.format(int(epochs), self.frac_balance) - hist_fmt = 'ensemble_histories' + fmt_table - pred_fmt = 'ensemble_predval' + fmt_table + fmt_table = "_i{0:04d}_b{1}.txt".format(int(epochs), self.frac_balance) + hist_fmt = "ensemble_histories" + fmt_table + pred_fmt = "ensemble_predval" + fmt_table - table.write(os.path.join(self.output_dir, hist_fmt), format='ascii') - val_table.write(os.path.join(self.output_dir, pred_fmt), format='ascii', - fast_writer=False) + table.write(os.path.join(self.output_dir, hist_fmt), format="ascii") + val_table.write( + os.path.join(self.output_dir, pred_fmt), + format="ascii", + fast_writer=False, + ) if pred_test is True: - test_fmt = 'ensemble_predtest' + fmt_table - test_table.write(os.path.join(self.output_dir, test_fmt), format='ascii', - fast_writer=False) - - - def cross_validation(self, seed=2, epochs=350, batch_size=64, - n_splits=5, shuffle=False, pred_test=False, save=False): + test_fmt = "ensemble_predtest" + fmt_table + test_table.write( + os.path.join(self.output_dir, test_fmt), + format="ascii", + fast_writer=False, + ) + + def cross_validation( + self, + seed=2, + epochs=350, + batch_size=64, + n_splits=5, + shuffle=False, + pred_test=False, + save=False, + ): """ Performs cross validation for a given number of K-folds. Reassigns the training and validation sets for each fold. @@ -313,12 +397,20 @@ def cross_validation(self, seed=2, epochs=350, batch_size=64, crossval_predval : astropy.table.Table Table of predictions on the validation set from each fold. crossval_predtest : astropy.table.Table - Table of predictions on the test set from each fold. ONLY + Table of predictions on the test set from each fold. ONLY EXISTS IF PRED_TEST IS TRUE. crossval_histories : astropy.table.Table Table of history values from the model run on each fold. """ + if getattr(self, "ds", None) is None: + warnings.warn( + "No stella.DataSet provided. Training requires ConvNN(ds=...). For inference, use predict()." + ) + raise ValueError( + "Training requires a stella.DataSet (ConvNN(ds=...)). For inference, use predict(modelname=..., ...)." + ) + from sklearn.model_selection import KFold from sklearn.metrics import precision_recall_curve from sklearn.metrics import average_precision_score @@ -342,51 +434,62 @@ def cross_validation(self, seed=2, epochs=350, batch_size=64, i = 0 for ti, vi in kf.split(y_trainval): # CREATES TRAINING AND VALIDATION SETS - x_train = x_trainval[ti] + x_train = x_trainval[ti] y_train = y_trainval[ti] - x_val = x_trainval[vi] + x_val = x_trainval[vi] y_val = y_trainval[vi] p_val = p_trainval[vi] t_val = t_trainval[vi] - + # REFORMAT TO ADD ADDITIONAL CHANNEL TO DATA x_train = x_train.reshape(x_train.shape[0], x_train.shape[1], 1) x_val = x_val.reshape(x_val.shape[0], x_val.shape[1], 1) - + # CREATES MODEL AND RUNS ON REFOLDED TRAINING AND VALIDATION SETS self.create_model(seed) - history = self.model.fit(x_train, y_train, - epochs=epochs, - batch_size=batch_size, shuffle=shuffle, - validation_data=(x_val, y_val)) + history = self.model.fit( + x_train, + y_train, + epochs=epochs, + batch_size=batch_size, + shuffle=shuffle, + validation_data=(x_val, y_val), + ) # SAVES THE MODEL BY DEFAULT - self.model.save(os.path.join(self.output_dir, 'crossval_s{0:04d}_i{1:04d}_b{2}_f{3:04d}.h5'.format(int(seed), - int(epochs), - self.frac_balance, - i))) - + self.model.save( + os.path.join( + self.output_dir, + "crossval_s{0:04d}_i{1:04d}_b{2}_f{3:04d}.keras".format( + int(seed), int(epochs), self.frac_balance, i + ), + ) + ) # CALCULATE METRICS FOR VALIDATION SET pred_val = self.model.predict(x_val) pred_val = np.reshape(pred_val, len(pred_val)) # SAVES PREDS FOR VALIDATION SET - tab_names = ['id', 'gt', 'peak', 'pred'] + tab_names = ["id", "gt", "peak", "pred"] data = [t_val, y_val, p_val, pred_val] for j, tn in enumerate(tab_names): - col = Column(data[j], name=tn+'_f{0:03d}'.format(i)) + col = Column(data[j], name=tn + "_f{0:03d}".format(i)) predtab.add_column(col) # PREDICTS ON TEST SET IF PRED_TEST IS TRUE if pred_test is True: preds = self.model.predict(self.ds.test_data) preds = np.reshape(preds, len(preds)) - data = [self.ds.test_ids, self.ds.test_labels, self.ds.test_tpeaks, - np.reshape(preds, len(preds))] + data = [ + self.ds.test_ids, + self.ds.test_labels, + self.ds.test_tpeaks, + np.reshape(preds, len(preds)), + ] for j, tn in enumerate(tab_names): - col = Column(data[j], name=tn+'_f{0:03d}'.format(i)) + col = Column(data[j], name=tn + "_f{0:03d}".format(i)) pred_test_table.add_column(col) self.crossval_predtest = pred_test_table @@ -396,7 +499,7 @@ def cross_validation(self, seed=2, epochs=350, batch_size=64, # SAVES HISTORIES TO A TABLE col_names = list(history.history.keys()) for cn in col_names: - col = Column(history.history[cn], name=cn+'_f{0:03d}'.format(i)) + col = Column(history.history[cn], name=cn + "_f{0:03d}".format(i)) tab.add_column(col) # KEEPS TRACK OF WHICH FOLD @@ -408,54 +511,81 @@ def cross_validation(self, seed=2, epochs=350, batch_size=64, # IF SAVE IS TRUE, SAVES TABLES TO OUTPUT DIRECTORY if save is True: - fmt = 'crossval_{0}_s{1:04d}_i{2:04d}_b{3}.txt' - predtab.write(os.path.join(self.output_dir, fmt.format('predval', int(seed), - int(epochs), self.frac_balance)), format='ascii', - fast_writer=False) - tab.write(os.path.join(self.output_dir, fmt.format('histories', int(seed), - int(epochs), self.frac_balance)), format='ascii', - fast_writer=False) + fmt = "crossval_{0}_s{1:04d}_i{2:04d}_b{3}.txt" + predtab.write( + os.path.join( + self.output_dir, + fmt.format("predval", int(seed), int(epochs), self.frac_balance), + ), + format="ascii", + fast_writer=False, + ) + tab.write( + os.path.join( + self.output_dir, + fmt.format("histories", int(seed), int(epochs), self.frac_balance), + ), + format="ascii", + fast_writer=False, + ) # SAVES TEST SET PREDICTIONS IF TRUE if pred_test is True: - pred_test_table.write(os.path.join(self.output_dir, fmt.format('predtest', int(seed), - int(epochs), self.frac_balance)), - format='ascii', fast_writer=False) - + pred_test_table.write( + os.path.join( + self.output_dir, + fmt.format( + "predtest", int(seed), int(epochs), self.frac_balance + ), + ), + format="ascii", + fast_writer=False, + ) def calibration(self, df, metric_threshold): """ - Transforming the rankings output by the CNN into actual probabilities. + Transform the rankings output by the CNN into probabilities. This can only be run for an ensemble of models. Parameters ---------- - df : astropy.Table.table + df : astropy.table.Table Table of output predictions from the validation set. metric_threshold : float - Defines ranking above which something is considered - a flares. + Defines ranking above which something is considered a flare. """ # ADD COLUMN TO TABLE THAT CALCULATES THE FRACTION OF MODELS # THAT SAY SOMETHING IS A FLARE - names= [i for i in df.colnames if 's' in i] + names = [i for i in df.colnames if "s" in i] flare_frac = np.zeros(len(df)) - for i, val in enumerate(len(df)): + for i in range(len(df)): preds = np.array(list(df[names][i])) - flare_frac[i] = len(preds[preds >= threshold]) / len(preds) + flare_frac[i] = len(preds[preds >= metric_threshold]) / len(preds) - df.add_column(Column(flare_frac, name='flare_frac')) - - # !! WORK IN PROGRESS !! + df.add_column(Column(flare_frac, name="flare_frac")) + # Placeholder for further calibration steps return df - - - def predict(self, modelname, times, fluxes, errs, - multi_models=False, injected=False): + + def predict( + self, + modelname, + times, + fluxes, + errs, + multi_models=False, + injected=False, + verbose=True, + progress: str = "auto", + window_batch: int = None, + tqdm_position: int = None, + tqdm_desc: str = None, + rich_progress: object = None, + rich_desc: str = None, + ): """ - Takes in arrays of time and flux and predicts where the flares + Takes in arrays of time and flux and predicts where the flares are based on the keras model created and trained. Parameters @@ -471,10 +601,10 @@ def predict(self, modelname, times, fluxes, errs, injected : bool, optional Returns predictions instead of setting attribute. Used for injection-recovery. Default is False. - + Attributes ---------- - model : tensorflow.python.keras.engine.sequential.Sequential + model : keras.models.Sequential The model input with modelname. predict_time : np.ndarray The input times array. @@ -489,7 +619,7 @@ def predict(self, modelname, times, fluxes, errs, def identify_gaps(t): """ Identifies which cadences can be predicted on given - locations of gaps in the data. Will always stay + locations of gaps in the data. Will always stay cadences/2 away from the gaps. Returns lists of good indices to predict on. @@ -500,18 +630,19 @@ def identify_gaps(t): all_inds = np.arange(0, len(t), 1, dtype=int) # REMOVES BEGINNING AND ENDS - bad_inds = np.arange(0,cad_pad,1,dtype=int) - bad_inds = np.append(bad_inds, np.arange(len(t)-cad_pad, - len(t), 1, dtype=int)) + bad_inds = np.arange(0, cad_pad, 1, dtype=int) + bad_inds = np.append( + bad_inds, np.arange(len(t) - cad_pad, len(t), 1, dtype=int) + ) diff = np.diff(t) med, std = np.nanmedian(diff), np.nanstd(diff) - - bad = np.where(np.abs(diff) >= med + 1.5*std)[0] + + bad = np.where(np.abs(diff) >= med + 1.5 * std)[0] for b in bad: - bad_inds = np.append(bad_inds, np.arange(b-cad_pad, - b+cad_pad, - 1, dtype=int)) + bad_inds = np.append( + bad_inds, np.arange(b - cad_pad, b + cad_pad, 1, dtype=int) + ) bad_inds = np.sort(bad_inds) return np.delete(all_inds, bad_inds) @@ -520,53 +651,198 @@ def identify_gaps(t): self.model = model # GETS REQUIRED INPUT SHAPE FROM MODEL - cadences = model.input.shape[1] - cad_pad = cadences/2 + cadences = int(model.input_shape[1]) + cad_pad = cadences // 2 # REFORMATS FOR A SINGLE LIGHT CURVE PASSED IN - try: - times[0][0] - except: - times = [times] + if np.ndim(times) == 1: + times = [times] fluxes = [fluxes] - errs = [errs] - + errs = [errs] predictions = [] pred_t, pred_f, pred_e = [], [], [] - - for j in tqdm(range(len(times))): - time = times[j] + 0.0 - lc = fluxes[j] / np.nanmedian(fluxes[j]) # MUST BE NORMALIZED - err = errs[j] + 0.0 - - q = ( (np.isnan(time) == False) & (np.isnan(lc) == False)) - time, lc, err = time[q], lc[q], err[q] - - # APPENDS MASKED LIGHT CURVES TO KEEP TRACK OF - pred_t.append(time) - pred_f.append(lc) - pred_e.append(err) - - good_inds = identify_gaps(time) - - reshaped_data = np.zeros((len(lc), cadences)) - - for i in good_inds: - loc = [int(i-cad_pad), int(i+cad_pad)] - f = lc[loc[0]:loc[1]] - t = time[loc[0]:loc[1]] - reshaped_data[i] = f - - reshaped_data = reshaped_data.reshape(reshaped_data.shape[0], - reshaped_data.shape[1], 1) - - - preds = model.predict(reshaped_data) - preds = np.reshape(preds, (len(preds),)) - predictions.append(preds) - - self.predict_time = np.array(pred_t) - self.predict_flux = np.array(pred_f) - self.predict_err = np.array(pred_e) - self.predictions = np.array(predictions) + + # Outer progress for multiple light curves + # Outer bar only if predicting multiple light curves (rare in notebooks) + show_outer = verbose and (len(times) > 1) + def _tqdm_args(**kwargs): + mod = getattr(tqdm, "__module__", "") + if mod.startswith("tqdm.rich"): + kwargs.pop("position", None) + kwargs.pop("dynamic_ncols", None) + return kwargs + + if show_outer: + with tqdm(total=len(times), desc="Light Curves", **_tqdm_args(position=(tqdm_position or 1), leave=False)) as pbar: + for j in range(len(times)): + time = np.array(times[j], dtype=float) + lc = np.array(fluxes[j], dtype=float) + err = np.array(errs[j], dtype=float) + + med = np.nanmedian(lc) + if not np.isfinite(med) or med == 0.0: + med = 1.0 + lc = lc / med + + q = (~np.isnan(time)) & (~np.isnan(lc)) + if err is not None and err.shape == time.shape: + q = q & (~np.isnan(err)) + time, lc = time[q], lc[q] + err = err[q] if err is not None else None + + # APPENDS MASKED LIGHT CURVES TO KEEP TRACK OF + pred_t.append(time) + pred_f.append(lc) + pred_e.append(err if err is not None else np.zeros_like(time)) + + good_inds = identify_gaps(time) + + reshaped_data = np.zeros((len(lc), cadences)) + for i in good_inds: + loc0 = int(i - cad_pad) + loc1 = int(i + cad_pad) + reshaped_data[i] = lc[loc0:loc1] + + reshaped_data = reshaped_data.reshape( + reshaped_data.shape[0], reshaped_data.shape[1], 1 + ) + + # Suppress Keras internal bar to avoid duplicates; rely on our bars below + predict_verbose = 0 + # Always show a per-model window bar in notebooks when verbose + if verbose and (progress in ("auto", "windows")): + total_windows = reshaped_data.shape[0] + bs = window_batch if window_batch is not None else max(1024, cadences) + preds = np.zeros((total_windows,), dtype=float) + if HAVE_RICH: + for i0 in track(range(0, total_windows, bs), description=(rich_desc or tqdm_desc or "Model Predict")): + i1 = min(i0 + bs, total_windows) + batch = reshaped_data[i0:i1] + out = model.predict(batch, verbose=0) + out = np.reshape(out, (len(out),)) + preds[i0:i1] = out + else: + with tqdm( + total=total_windows, + desc=(tqdm_desc or "Model Predict"), + **_tqdm_args(position=(tqdm_position or 1), leave=False, dynamic_ncols=True), + ) as wbar: + for i0 in range(0, total_windows, bs): + i1 = min(i0 + bs, total_windows) + batch = reshaped_data[i0:i1] + out = model.predict(batch, verbose=0) + out = np.reshape(out, (len(out),)) + preds[i0:i1] = out + wbar.update(i1 - i0) + # ensure visual completion + if wbar.n < (wbar.total or 0): + wbar.update((wbar.total or 0) - wbar.n) + wbar.refresh() + else: + preds = model.predict(reshaped_data, verbose=predict_verbose) + preds = np.reshape(preds, (len(preds),)) + predictions.append(preds) + pbar.update(1) + # ensure visual completion + if pbar.n < (pbar.total or 0): + pbar.update((pbar.total or 0) - pbar.n) + pbar.refresh() + else: + for j in range(len(times)): + time = np.array(times[j], dtype=float) + lc = np.array(fluxes[j], dtype=float) + err = np.array(errs[j], dtype=float) + + med = np.nanmedian(lc) + if not np.isfinite(med) or med == 0.0: + med = 1.0 + lc = lc / med + + q = (~np.isnan(time)) & (~np.isnan(lc)) + if err is not None and err.shape == time.shape: + q = q & (~np.isnan(err)) + time, lc = time[q], lc[q] + err = err[q] if err is not None else None + + # APPENDS MASKED LIGHT CURVES TO KEEP TRACK OF + pred_t.append(time) + pred_f.append(lc) + pred_e.append(err if err is not None else np.zeros_like(time)) + + good_inds = identify_gaps(time) + + reshaped_data = np.zeros((len(lc), cadences)) + for i in good_inds: + loc0 = int(i - cad_pad) + loc1 = int(i + cad_pad) + reshaped_data[i] = lc[loc0:loc1] + + reshaped_data = reshaped_data.reshape( + reshaped_data.shape[0], reshaped_data.shape[1], 1 + ) + + # Suppress Keras internal bar to avoid duplicates; rely on our bars below + predict_verbose = 0 + # Always show a per-model window bar in notebooks when verbose + if verbose and (progress in ("auto", "windows")): + total_windows = reshaped_data.shape[0] + bs = window_batch if window_batch is not None else max(1024, cadences) + preds = np.zeros((total_windows,), dtype=float) + if rich_progress is not None and HAVE_RICH: + task_id = rich_progress.add_task( + (rich_desc or tqdm_desc or "Model Predict"), total=total_windows + ) + try: + for i0 in range(0, total_windows, bs): + i1 = min(i0 + bs, total_windows) + batch = reshaped_data[i0:i1] + out = model.predict(batch, verbose=0) + out = np.reshape(out, (len(out),)) + preds[i0:i1] = out + rich_progress.update(task_id, advance=(i1 - i0)) + finally: + try: + rich_progress.update(task_id, completed=total_windows) + except Exception: + pass + else: + wbar = tqdm( + total=total_windows, + desc=(tqdm_desc or "Model Predict"), + **_tqdm_args(position=(tqdm_position or 1), leave=False, dynamic_ncols=True), + ) + try: + for i0 in range(0, total_windows, bs): + i1 = min(i0 + bs, total_windows) + batch = reshaped_data[i0:i1] + out = model.predict(batch, verbose=0) + out = np.reshape(out, (len(out),)) + preds[i0:i1] = out + wbar.update(i1 - i0) + finally: + try: + remaining = (wbar.total or 0) - (wbar.n or 0) + if remaining > 0: + wbar.update(remaining) + wbar.refresh() + except Exception: + pass + wbar.close() + else: + preds = model.predict(reshaped_data, verbose=predict_verbose) + preds = np.reshape(preds, (len(preds),)) + predictions.append(preds) + + self.predict_time = np.array(pred_t, dtype=object) + self.predict_flux = np.array(pred_f, dtype=object) + self.predict_err = np.array(pred_e, dtype=object) + self.predictions = np.array(predictions, dtype=object) + + if injected: + return ( + self.predict_time, + self.predict_flux, + self.predict_err, + self.predictions, + ) diff --git a/stella/pipeline.py b/stella/pipeline.py new file mode 100644 index 0000000..94001f4 --- /dev/null +++ b/stella/pipeline.py @@ -0,0 +1,312 @@ +import os +import numpy as np +from typing import Iterable, List, Optional, Sequence, Tuple, Union +try: + try: + from rich.progress import ( + Progress, + SpinnerColumn, + BarColumn, + TimeRemainingColumn, + MofNCompleteColumn, + TextColumn, + track, + ) + HAVE_RICH = True + except Exception: # pragma: no cover + HAVE_RICH = False + from tqdm.rich import tqdm # prefer thin rich-style bars when falling back + def _tqdm_args(**kwargs): + mod = getattr(tqdm, "__module__", "") + if mod.startswith("tqdm.rich"): + kwargs.pop("position", None) + kwargs.pop("dynamic_ncols", None) + return kwargs +except Exception: # pragma: no cover + from tqdm.auto import tqdm + +os.environ.setdefault("KERAS_BACKEND", "jax") + +import keras + +from .neural_network import ConvNN +from .mark_flares import FitFlares + +__all__ = [ + "predict", + "predict_ensemble", + "predict_and_mark", + "mark_flares_from_preds", + "remove_false_positives", +] + + +def _to_np(x): + if hasattr(x, "value"): + return np.asarray(x.value) + return np.asarray(x) + + +def _extract_series( + lc_or_times: Union[object, Sequence[float], np.ndarray], + flux: Optional[Union[Sequence[float], np.ndarray]] = None, + flux_err: Optional[Union[Sequence[float], np.ndarray]] = None, +) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + """ + Accept either a lightkurve LightCurve-like object or (times, flux, flux_err). + Ensures arrays are numpy and strips astropy units via .value when present. + """ + # LightCurve-like path (duck typing) + if flux is None and hasattr(lc_or_times, "time") and hasattr(lc_or_times, "flux"): + lc = lc_or_times + # Apply filtering whenever a LightCurve-like object is passed + try: + if hasattr(lc, "remove_nans"): + lc = lc.remove_nans().normalize() + if hasattr(lc, "quality"): + try: + lc = lc[lc.quality == 0] + except Exception: + pass + except Exception: + # Best-effort: continue without mutation + pass + + t = _to_np(getattr(lc.time, "value", getattr(lc, "time", None))) + f = _to_np(getattr(lc.flux, "value", getattr(lc, "flux", None))) + if hasattr(lc, "flux_err") and lc.flux_err is not None: + e = _to_np(getattr(lc.flux_err, "value", getattr(lc, "flux_err", None))) + else: + e = np.zeros_like(f) + return t, f, e + + # Tuple/arrays path + if flux is None or flux_err is None: + raise ValueError( + "Provide either a LightCurve-like object or (times, flux, flux_err) arrays." + ) + t = _to_np(lc_or_times) + f = _to_np(flux) + e = _to_np(flux_err) + return t, f, e + + +def predict( + model_path: str, + lc_or_times: Union[object, Sequence[float], np.ndarray], + flux: Optional[Union[Sequence[float], np.ndarray]] = None, + flux_err: Optional[Union[Sequence[float], np.ndarray]] = None, + verbose: bool = True, + progress: str = "auto", + window_batch: Optional[int] = None, + tqdm_position: Optional[int] = None, + tqdm_desc: Optional[str] = None, + rich_progress: Optional[object] = None, + rich_desc: Optional[str] = None, +) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """ + Run a single Keras (.keras) model to produce per-cadence predictions. + Returns (times, flux, errs, preds) for convenience. + """ + t, f, e = _extract_series(lc_or_times, flux, flux_err) + + cnn = ConvNN(output_dir=".") + cnn.predict( + modelname=model_path, + times=t, + fluxes=f, + errs=e, + verbose=verbose, + progress=progress, + window_batch=window_batch, + tqdm_position=tqdm_position, + tqdm_desc=tqdm_desc, + rich_progress=rich_progress, + rich_desc=rich_desc, + ) + # predictions is shape (1, N) + preds = np.asarray(cnn.predictions[0]) + return cnn.predict_time[0], cnn.predict_flux[0], cnn.predict_err[0], preds + + +def predict_ensemble( + model_paths: Sequence[str], + lc_or_times: Union[object, Sequence[float], np.ndarray], + flux: Optional[Union[Sequence[float], np.ndarray]] = None, + flux_err: Optional[Union[Sequence[float], np.ndarray]] = None, + aggregate: str = "mean", + verbose: bool = True, + progress: str = "auto", + window_batch: Optional[int] = None, +) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """ + Run an ensemble of models and aggregate predictions. + aggregate: 'mean' or 'median'. + Returns (times, flux, errs, agg_preds, per_model_preds[models, N]). + """ + t, f, e = _extract_series(lc_or_times, flux, flux_err) + per_model = [] + t_ref = f_ref = e_ref = None + + show_outer = verbose and (len(model_paths) > 1) + if HAVE_RICH and show_outer: + # Use Rich's track for reliable completion + for idx, mp in enumerate(track(model_paths, description="Models")): + tt, ff, ee, pr = predict( + mp, + t, + f, + e, + verbose=verbose, + progress=progress, + window_batch=window_batch, + tqdm_position=1, + tqdm_desc=f"Model {idx+1}/{len(model_paths)}", + ) + if t_ref is None: + t_ref, f_ref, e_ref = tt, ff, ee + per_model.append(pr) + else: + # Fallback to tqdm using a context manager (no finally) + if show_outer: + with tqdm(total=len(model_paths), desc="Models") as pbar: + for idx, mp in enumerate(model_paths): + tt, ff, ee, pr = predict( + mp, + t, + f, + e, + verbose=verbose, + progress=progress, + window_batch=window_batch, + tqdm_position=1, + tqdm_desc=f"Model {idx+1}/{len(model_paths)}", + ) + if t_ref is None: + t_ref, f_ref, e_ref = tt, ff, ee + per_model.append(pr) + pbar.update(1) + # ensure visual completion + if pbar.n < (pbar.total or 0): + pbar.update((pbar.total or 0) - pbar.n) + pbar.refresh() + else: + for idx, mp in enumerate(model_paths): + tt, ff, ee, pr = predict( + mp, + t, + f, + e, + verbose=verbose, + progress=progress, + window_batch=window_batch, + tqdm_position=1, + tqdm_desc=f"Model {idx+1}/{len(model_paths)}", + ) + if t_ref is None: + t_ref, f_ref, e_ref = tt, ff, ee + per_model.append(pr) + + per_model = np.asarray(per_model) + if aggregate == "median": + agg = np.nanmedian(per_model, axis=0) + else: + agg = np.nanmean(per_model, axis=0) + return t_ref, f_ref, e_ref, agg, per_model + + +def mark_flares_from_preds( + target_id: Union[str, int], + times: np.ndarray, + flux: np.ndarray, + errs: np.ndarray, + preds: np.ndarray, + threshold: float = 0.5, +): + """ + Identify flares from precomputed predictions. + Returns (fit, flare_table). + """ + fit = FitFlares( + id=np.asarray([target_id]), + time=np.asarray([times]), + flux=np.asarray([flux]), + flux_err=np.asarray([errs]), + predictions=np.asarray([preds]), + ) + fit.identify_flare_peaks(threshold=threshold) + return fit, fit.flare_table + + +def predict_and_mark( + model_or_models: Union[str, Sequence[str]], + lc_or_times: Union[object, Sequence[float], np.ndarray], + flux: Optional[Union[Sequence[float], np.ndarray]] = None, + flux_err: Optional[Union[Sequence[float], np.ndarray]] = None, + target_id: Union[str, int] = "target", + threshold: float = 0.5, + aggregate: str = "mean", + verbose: bool = True, +): + """ + Convenience wrapper: predict (single or ensemble) and mark flares. + Returns (times, flux, errs, preds, flare_table). + """ + if isinstance(model_or_models, (list, tuple)): + t, f, e, preds, _ = predict_ensemble( + model_or_models, + lc_or_times, + flux, + flux_err, + aggregate=aggregate, + verbose=verbose, + ) + else: + t, f, e, preds = predict( + model_or_models, lc_or_times, flux, flux_err, verbose=verbose + ) + + _, table = mark_flares_from_preds(target_id, t, f, e, preds, threshold=threshold) + return t, f, e, preds, table + + +def remove_false_positives( + flare_table, + min_duration_min: float = 4.0, + drop_indices: Optional[Sequence[int]] = None, +): + """ + Basic false-positive filtering for a flare table. + + - Removes flares with fitted duration shorter than `min_duration_min` minutes, + where duration = (rise + fall) in days converted to minutes. + - Optionally removes rows by 0-based indices via `drop_indices`. + + Returns a filtered copy of the table. + """ + from astropy.table import Table + import numpy as np + + if not isinstance(flare_table, Table): + # Best-effort cast + try: + flare_table = Table(flare_table) + except Exception: + raise TypeError("flare_table must be an Astropy Table or table-like object") + + mask = np.ones(len(flare_table), dtype=bool) + + if all(c in flare_table.colnames for c in ("rise", "fall")): + durations_min = ( + (np.array(flare_table["rise"]) + np.array(flare_table["fall"])) * 24 * 60 + ) + mask &= durations_min >= float(min_duration_min) + + if drop_indices: + drop_indices = set(int(i) for i in drop_indices) + keep = [i for i in range(len(flare_table)) if i not in drop_indices] + mask2 = np.zeros(len(flare_table), dtype=bool) + mask2[keep] = True + mask &= mask2 + + return flare_table[mask] diff --git a/stella/preprocessing_flares.py b/stella/preprocessing_flares.py index 4d48a4b..8a92eb1 100755 --- a/stella/preprocessing_flares.py +++ b/stella/preprocessing_flares.py @@ -6,7 +6,7 @@ from .utils import break_rest, do_the_shuffle, split_data -__all__ = ['FlareDataSet'] +__all__ = ["FlareDataSet"] class FlareDataSet(object): @@ -23,14 +23,20 @@ class FlareDataSet(object): This class additionally requires a catalog of flare start times for labeling. The flare catalog can be in either '.txt' or '.csv' file format. This class will - be passed into the stella.neural_network() class to + be passed into the stella.neural_network() class to create and train the neural network. """ - def __init__(self, fn_dir=None, catalog=None, - downloadSet=None, - cadences=200, frac_balance=0.73, - training=0.80, validation=0.90): + def __init__( + self, + fn_dir=None, + catalog=None, + downloadSet=None, + cadences=200, + frac_balance=0.73, + training=0.80, + validation=0.90, + ): """ Loads in time, flux, flux error data. Reshapes arrays into `cadences`-sized bins and labels @@ -42,15 +48,15 @@ def __init__(self, fn_dir=None, catalog=None, The path to where the files for the training set are stored. catalog : str, optional - The path and filename of the catalog with + The path and filename of the catalog with marked flare start times downloadSet : stella.DownloadSets, optional - The stella.DownloadSets class, which contains the + The stella.DownloadSets class, which contains the flare catalog name and directory where light curves and the catalog are saved. cadences : int, optional The size of each training set. Default is 200. - frac_balance : float, optional + frac_balance : float, optional The amount of the negative class to remove. Default is 0.75. training : float, optional @@ -61,9 +67,9 @@ def __init__(self, fn_dir=None, catalog=None, data for the model. Default is 90%. """ if fn_dir is not None: - self.fn_dir = fn_dir + self.fn_dir = fn_dir if catalog is not None: - self.catalog = Table.read(catalog, format='ascii') + self.catalog = Table.read(catalog, format="ascii") if downloadSet is not None: self.fn_dir = downloadSet.fn_dir @@ -75,11 +81,16 @@ def __init__(self, fn_dir=None, catalog=None, self.load_files() self.reformat_data() - misc = split_data(self.labels, self.training_matrix, - self.training_ids, self.training_peaks, - training, validation) + misc = split_data( + self.labels, + self.training_matrix, + self.training_ids, + self.training_peaks, + training, + validation, + ) - self.train_data = misc[0] + self.train_data = misc[0] self.train_labels = misc[1] self.val_data = misc[2] @@ -93,19 +104,17 @@ def __init__(self, fn_dir=None, catalog=None, self.test_ids = misc[8] self.test_tpeaks = misc[9] - - def load_files(self, id_keyword='TIC', ft_keyword='tpeak', - time_offset=2457000.0): + def load_files(self, id_keyword="TIC", ft_keyword="tpeak", time_offset=2457000.0): """ Loads in light curves from the assigned training set - directory. Files must be formatted such that the ID - of each star is first and followed by '_' + directory. Files must be formatted such that the ID + of each star is first and followed by '_' (e.g. 123456789_sector09.npy). Attributes ---------- times : np.ndarray - An n-dimensional array of times, where n is the + An n-dimensional array of times, where n is the number of training set files. fluxes : np.ndarray An n-dimensional array of fluxes, where n is the @@ -117,45 +126,45 @@ def load_files(self, id_keyword='TIC', ft_keyword='tpeak', An array of light curve IDs for each time/flux/flux_err. This is essential for labeling flare events. id_keyword : str, optional - The column header in catalog to identify target ID. + The column header in catalog to identify target ID. Default is 'tic_id'. ft_keyword : str, optional The column header in catalog to identify flare peak time. Default is 'tpeak'. - time_offset : float, optional + time_offset : float, optional Time correction from flare catalog to light curve and is - necessary when using Max Guenther's catalog. + necessary when using Max Guenther's catalog. Default is 2457000.0 """ print("Reading in training set files.") files = os.listdir(self.fn_dir) - - files = np.sort([i for i in files if i.endswith('.npy') and 'sector' in i]) - + + files = np.sort([i for i in files if i.endswith(".npy") and "sector" in i]) + tics, time, flux, err, tpeaks = [], [], [], [], [] - + for fn in files: data = np.load(os.path.join(self.fn_dir, fn), allow_pickle=True) - split_fn = fn.split('_') + split_fn = fn.split("_") tic = int(split_fn[0]) tics.append(tic) - sector = int(split_fn[1].split('r')[1][0:2]) + sector = int(split_fn[1].split("r")[1][0:2]) time.append(data[0]) flux.append(data[1]) - err.append( data[2]) - - peaks = self.catalog[(self.catalog[id_keyword] == tic)][ft_keyword].data -# (self.catalog['sector'] == sector)][ft_keyword].data + err.append(data[2]) + + peaks = self.catalog[(self.catalog[id_keyword] == tic)][ft_keyword].data + # (self.catalog['sector'] == sector)][ft_keyword].data peaks = peaks - time_offset tpeaks.append(peaks) - self.ids = np.array(tics) - self.time = np.array(time, dtype=np.ndarray) # in TBJD - self.flux = np.array(flux, dtype=np.ndarray) - self.flux_err = np.array(err, dtype=np.ndarray) - self.tpeaks = tpeaks # in TBJD + self.ids = np.array(tics) + self.time = np.array(time, dtype=np.ndarray) # in TBJD + self.flux = np.array(flux, dtype=np.ndarray) + self.flux_err = np.array(err, dtype=np.ndarray) + self.tpeaks = tpeaks # in TBJD def reformat_data(self, random_seed=321): """ @@ -180,64 +189,69 @@ def reformat_data(self, random_seed=321): training_matrix = np.zeros((ss, self.cadences)) training_labels = np.zeros(ss, dtype=int) - training_peaks = np.zeros(ss) - training_ids = np.zeros(ss) - + training_peaks = np.zeros(ss) + training_ids = np.zeros(ss) + x = 0 - + for i in tqdm(range(len(self.time))): flares = np.array([], dtype=int) - + for peak in self.tpeaks[i]: - arg = np.where((self.time[i]>(peak-0.02)) & (self.time[i]<(peak+0.02)))[0] - # DOESN'T LIKE FLARES AT THE VERY END OF THE LIGHT CURVE + arg = np.where( + (self.time[i] > (peak - 0.02)) & (self.time[i] < (peak + 0.02)) + )[0] + # DOESN'T LIKE FLARES AT THE VERY END OF THE LIGHT CURVE # (AND NEITHER DO I) if len(arg) > 0: closest = arg[np.argmin(np.abs(peak - self.time[i][arg]))] - start = int(closest-self.cadences/2) - end = int(closest+self.cadences/2) + start = int(closest - self.cadences / 2) + end = int(closest + self.cadences / 2) if start < 0: start = 0 end = self.cadences if end > len(self.time[i]): start = start - (end - len(self.time[i])) end = len(self.time[i]) - flare_region = np.arange(start, end,1,dtype=int) + flare_region = np.arange(start, end, 1, dtype=int) flares = np.append(flares, flare_region) - + # ADD FLARE TO TRAINING MATRIX & LABEL PROPERLY - training_peaks[x] = self.time[i][closest] + 0.0 - training_ids[x] = self.ids[i] + 0.0 + training_peaks[x] = self.time[i][closest] + 0.0 + training_ids[x] = self.ids[i] + 0.0 training_matrix[x] = self.flux[i][flare_region] training_labels[x] = 1 x += 1 - + time_removed = np.delete(self.time[i], flares) flux_removed = np.delete(self.flux[i], flares) flux_err_removed = np.delete(self.flux_err[i], flares) - nontime, nonflux, nonerr = break_rest(time_removed, flux_removed, - flux_err_removed, self.cadences) + nontime, nonflux, nonerr = break_rest( + time_removed, flux_removed, flux_err_removed, self.cadences + ) for j in range(len(nonflux)): if x >= ss: break else: training_ids[x] = self.ids[i] + 0.0 - training_peaks[x] = nontime[j][int(self.cadences/2)] + training_peaks[x] = nontime[j][int(self.cadences / 2)] training_matrix[x] = nonflux[j] training_labels[x] = 0 x += 1 # DELETE EXTRA END OF TRAINING MATRIX AND LABELS - training_matrix = np.delete(training_matrix, np.arange(x, ss, 1, dtype=int), axis=0) - labels = np.delete(training_labels, np.arange(x, ss, 1, dtype=int)) - training_peaks = np.delete(training_peaks, np.arange(x, ss, 1, dtype=int)) - training_ids = np.delete(training_ids, np.arange(x, ss, 1, dtype=int)) + training_matrix = np.delete( + training_matrix, np.arange(x, ss, 1, dtype=int), axis=0 + ) + labels = np.delete(training_labels, np.arange(x, ss, 1, dtype=int)) + training_peaks = np.delete(training_peaks, np.arange(x, ss, 1, dtype=int)) + training_ids = np.delete(training_ids, np.arange(x, ss, 1, dtype=int)) - ids, matrix, label, peaks = do_the_shuffle(training_matrix, labels, training_peaks, - training_ids, self.frac_balance) + ids, matrix, label, peaks = do_the_shuffle( + training_matrix, labels, training_peaks, training_ids, self.frac_balance + ) self.labels = label - self.training_peaks = peaks - self.training_ids = ids + self.training_peaks = peaks + self.training_ids = ids self.training_matrix = matrix - diff --git a/stella/rotations.py b/stella/rotations.py index 7c8578f..1ee5c66 100644 --- a/stella/rotations.py +++ b/stella/rotations.py @@ -7,27 +7,61 @@ from astropy.table import Table, Column from astropy.timeseries import LombScargle -__all__ = ['MeasureProt'] +__all__ = ["MeasureProt"] + class MeasureProt(object): """ Used for measuring rotation periods. """ - + def __init__(self, IDs, time, flux, flux_err): """ - Takes in light curve identifiers, time, flux, + Takes in light curve identifiers, time, flux, and flux errors. """ - self.IDs = IDs - self.time = time - self.flux = flux - self.flux_err = flux_err - - + self.IDs = IDs + + def _to_float_array(x): + try: + # Prefer astropy-aware conversion when available + from astropy.time import Time # type: ignore + from astropy.units import Quantity # type: ignore + except Exception: + Time = None + Quantity = None + + try: + if Quantity is not None and isinstance(x, Quantity): + return np.asarray(x.to_value(), dtype=float) + except Exception: + pass + try: + if Time is not None and isinstance(x, Time): + return np.asarray(x.value, dtype=float) + except Exception: + pass + if hasattr(x, "value"): + try: + return np.asarray(x.value, dtype=float) + except Exception: + pass + return np.asarray(x, dtype=float) + + # Normalize inputs to plain float arrays to avoid Time/TimeDelta issues + self.time = [ + _to_float_array(t) for t in (time if isinstance(time, (list, tuple)) else [time]) + ] + self.flux = [ + _to_float_array(f) for f in (flux if isinstance(flux, (list, tuple)) else [flux]) + ] + self.flux_err = [ + _to_float_array(e) + for e in (flux_err if isinstance(flux_err, (list, tuple)) else [flux_err]) + ] def gauss_curve(self, x, std, scale, mu): - """ Fits a Gaussian to the peak of the LS + """Fits a Gaussian to the peak of the LS periodogram. Parameters @@ -44,13 +78,12 @@ def gauss_curve(self, x, std, scale, mu): ------- Gaussian curve. """ - term1 = 1.0 / (std * np.sqrt(2 * np.pi) ) - term2 = np.exp(-0.5 * ((x-mu)/std)**2) + term1 = 1.0 / (std * np.sqrt(2 * np.pi)) + term2 = np.exp(-0.5 * ((x - mu) / std) ** 2) return term1 * term2 * scale - def chiSquare(self, var, mu, x, y, yerr): - """ Calculates chi-square for fitting a Gaussian + """Calculates chi-square for fitting a Gaussian to the peak of the LS periodogram. Parameters @@ -68,11 +101,10 @@ def chiSquare(self, var, mu, x, y, yerr): chi-square value. """ m = self.gauss(x, var[0], var[1], mu) - return np.sum( (y-m)**2 / yerr**2 ) + return np.sum((y - m) ** 2 / yerr**2) - def fit_LS_peak(self, period, power, arg): - """ Fits the LS periodogram at the peak power. + """Fits the LS periodogram at the peak power. Parameters ---------- @@ -88,33 +120,40 @@ def fit_LS_peak(self, period, power, arg): popt : np.array Array of best fit values for Gaussian fit. """ + def fitting_routine(): - popt, pcov = curve_fit(self.gauss_curve, period[m], power[m], - p0 = [(np.nanmax(period[subm]) - np.nanmin(period[subm]))/2.0, - 0.02, - period[arg]], - maxfev = 5000) + popt, pcov = curve_fit( + self.gauss_curve, + period[m], + power[m], + p0=[ + (np.nanmax(period[subm]) - np.nanmin(period[subm])) / 2.0, + 0.02, + period[arg], + ], + maxfev=5000, + ) return popt - if arg-40 < 0: + if arg - 40 < 0: start = 0 else: - start = arg-40 - if arg+40 > len(period): - end = len(period)-1 + start = arg - 40 + if arg + 40 > len(period): + end = len(period) - 1 else: - end = arg+40 + end = arg + 40 m = np.arange(start, end, 1, dtype=int) - if arg-20 < 0: + if arg - 20 < 0: start = 0 else: - start = arg-20 + start = arg - 20 if arg + 20 > len(period): - end = len(period)-1 + end = len(period) - 1 else: - end = arg+20 + end = arg + 20 subm = np.arange(start, end, 1, dtype=int) @@ -126,19 +165,18 @@ def fitting_routine(): # TRIES TO READJUST FITTING WINDOW IF RANGE IS LARGER THAN PERIOD ARRAY except IndexError: if np.min(m) <= 0: - m = np.arange(0,arg+40,1,dtype=int) - subm = np.arange(0,arg+20,1, dtype=int) + m = np.arange(0, arg + 40, 1, dtype=int) + subm = np.arange(0, arg + 20, 1, dtype=int) elif np.max(m) > len(period): diff = np.max(m) - len(period) - m = np.arange(arg-40-diff, len(period)-diff, 1, dtype=int) - subm = np.arange(arg-20-diff, len(period)-diff-20, 1, dtype=int) + m = np.arange(arg - 40 - diff, len(period) - diff, 1, dtype=int) + subm = np.arange(arg - 20 - diff, len(period) - diff - 20, 1, dtype=int) popt = fitting_routine() return popt - - def run_LS(self, minf=1/12.5, maxf=1/0.1, spp=50): - """ Runs LS fit for each light curve. + def run_LS(self, minf=1 / 12.5, maxf=1 / 0.1, spp=50): + """Runs LS fit for each light curve. Parameters ---------- @@ -153,45 +191,46 @@ def run_LS(self, minf=1/12.5, maxf=1/0.1, spp=50): ---------- LS_results : astropy.table.Table """ + def per_orbit(t, f): nonlocal maxf, spp - minf = 1/(t[-1]-t[0]) - if minf > 1/12.0: - minf = 1/12.0 + minf = 1 / (t[-1] - t[0]) + if minf > 1 / 12.0: + minf = 1 / 12.0 - freq, power = LombScargle(t, f).autopower(minimum_frequency=minf, - maximum_frequency=maxf, - samples_per_peak=spp) + freq, power = LombScargle(t, f).autopower( + minimum_frequency=minf, maximum_frequency=maxf, samples_per_peak=spp + ) arg = np.argmax(power) - per = 1.0/freq + per = 1.0 / freq popt = self.fit_LS_peak(per, power, arg) - + ## SEARCHES & MASKS RESONANCES OF THE BEST-FIT PERIOD perlist = per[arg] * np.array([0.5, 1.0, 2.0, 4.0, 8.0]) remove_res = np.zeros(len(per)) - maskreg = int(spp/1.5) + maskreg = int(spp / 1.5) for p in perlist: - where = np.where( (per <= p))[0] + where = np.where((per <= p))[0] if len(where) > 0: ind = int(where[0]) - if ind-maskreg > 0 and ind 0 and ind < len(per) - maskreg: + remove_res[int(ind - maskreg) : int(ind + maskreg)] = 1 elif ind < maskreg: - remove_res[0:int(maskreg)] = 1 - elif ind > len(per)-maskreg: - remove_res[int(len(per)-maskreg):len(per)] = 1 - if perlist[1] == 1/minf: - remove_res[0:int(spp/2)] = 1 + remove_res[0 : int(maskreg)] = 1 + elif ind > len(per) - maskreg: + remove_res[int(len(per) - maskreg) : len(per)] = 1 + if perlist[1] == 1 / minf: + remove_res[0 : int(spp / 2)] = 1 rr = remove_res == 0 arg1 = np.argmax(power[rr]) - ## REDOS PERIOD ROUTINE FOR SECOND HIGHEST PEAK + ## REDOS PERIOD ROUTINE FOR SECOND HIGHEST PEAK if arg1 == len(per[rr]): - arg1 = int(arg1-3) + arg1 = int(arg1 - 3) popt2 = self.fit_LS_peak(per[rr], power[rr], arg1) - + maxpower = power[arg] secpower = power[rr][arg1] @@ -218,22 +257,28 @@ def per_orbit(t, f): for i in tqdm(range(len(self.flux)), desc="Finding most likely periods"): time, flux, flux_err = self.time[i], self.flux[i], self.flux_err[i] - + # SPLITS BY ORBIT diff = np.diff(time) - brk = np.where(diff >= np.nanmedian(diff)+14*np.nanstd(diff))[0] - + brk = np.where(diff >= np.nanmedian(diff) + 14 * np.nanstd(diff))[0] + if len(brk) > 1: - brk_diff = brk - (len(time)/2) + brk_diff = brk - (len(time) / 2) try: - brk_diff = np.where(brk_diff<0)[0][-1] + brk_diff = np.where(brk_diff < 0)[0][-1] except IndexError: brk_diff = np.argmin(brk_diff) brk = np.array([brk[brk_diff]], dtype=int) # DEFINITELY TRIMS OUT EARTHSHINE MOFO - t1, f1 = time[:brk[0]], flux[:brk[0]]#[300:-500], flux[:brk[0]]#[300:-500] - t2, f2 = time[brk[0]:], flux[brk[0]:]#[800:-200], flux[brk[0]:]#[800:-200] + t1, f1 = ( + time[: brk[0]], + flux[: brk[0]], + ) # [300:-500], flux[:brk[0]]#[300:-500] + t2, f2 = ( + time[brk[0] :], + flux[brk[0] :], + ) # [800:-200], flux[brk[0]:]#[800:-200] o1_params = per_orbit(t1, f1) o2_params = per_orbit(t2, f2) @@ -241,80 +286,99 @@ def per_orbit(t, f): both = np.array([o1_params[0], o2_params[0]]) avg_period = np.nanmedian(both) - - flag1 = self.assign_flag(o1_params[0], o1_params[2], o1_params[-1], - avg_period, o1_params[-2], t1[-1]-t1[0]) - flag2 = self.assign_flag(o2_params[0], o2_params[2], o2_params[-1], - avg_period, o2_params[-2], t2[-1]-t2[0]) - - if np.abs(o1_params[1]-avg_period) < 0.5 and np.abs(o2_params[1]-avg_period)<0.5: + flag1 = self.assign_flag( + o1_params[0], + o1_params[2], + o1_params[-1], + avg_period, + o1_params[-2], + t1[-1] - t1[0], + ) + flag2 = self.assign_flag( + o2_params[0], + o2_params[2], + o2_params[-1], + avg_period, + o2_params[-2], + t2[-1] - t2[0], + ) + + if ( + np.abs(o1_params[1] - avg_period) < 0.5 + and np.abs(o2_params[1] - avg_period) < 0.5 + ): flag1 = flag2 = 0.0 if flag1 != 0 and flag2 != 0: orbit_flag[i] = 1.0 else: orbit_flag[i] = 0.0 - + periods[i] = np.nanmedian([o1_params[0], o2_params[0]]) - + orbit_flag1[i] = flag1 orbit_flag2[i] = flag2 - - stds[i] = o1_params[-1] + + stds[i] = o1_params[-1] peak_power[i] = o1_params[2] periods2[i] = o2_params[0] peak_power2[i] = o1_params[-2] - tab.add_column(Column(self.IDs, 'Target_ID')) - tab.add_column(Column(periods, name='period_days')) - tab.add_column(Column(periods2, name='secondary_period_days')) - tab.add_column(Column(stds, name='gauss_width')) - tab.add_column(Column(peak_power, name='max_power')) - tab.add_column(Column(peak_power2, name='secondary_max_power')) - tab.add_column(Column(orbit_flag, name='orbit_flag')) - tab.add_column(Column(orbit_flag1, name='oflag1')) - tab.add_column(Column(orbit_flag2, name='oflag2')) + tab.add_column(Column(self.IDs, "Target_ID")) + tab.add_column(Column(periods, name="period_days")) + tab.add_column(Column(periods2, name="secondary_period_days")) + tab.add_column(Column(stds, name="gauss_width")) + tab.add_column(Column(peak_power, name="max_power")) + tab.add_column(Column(peak_power2, name="secondary_max_power")) + tab.add_column(Column(orbit_flag, name="orbit_flag")) + tab.add_column(Column(orbit_flag1, name="oflag1")) + tab.add_column(Column(orbit_flag2, name="oflag2")) tab = self.averaged_per_sector(tab) self.LS_results = tab - - - def assign_flag(self, period, power, width, avg, secpow, - maxperiod, orbit_flag=0): - """ Assigns a flag in the table for which periods are reliable. - """ + def assign_flag(self, period, power, width, avg, secpow, maxperiod, orbit_flag=0): + """Assigns a flag in the table for which periods are reliable.""" flag = 100 if period > maxperiod: flag = 4 if (period < maxperiod) and (power > 0.005): flag = 3 - if (period < maxperiod) and (width <= period*0.6) and (power > 0.005): + if (period < maxperiod) and (width <= period * 0.6) and (power > 0.005): flag = 2 - if ( (period < maxperiod) and (width <= period*0.6) and - (secpow < 0.96*power) and (power > 0.005)): + if ( + (period < maxperiod) + and (width <= period * 0.6) + and (secpow < 0.96 * power) + and (power > 0.005) + ): flag = 1 - if ( (period < maxperiod) and (width <= period*0.6) and - (secpow < 0.96*power) and (np.abs(period-avg)<1.0) and (power > 0.005)): + if ( + (period < maxperiod) + and (width <= period * 0.6) + and (secpow < 0.96 * power) + and (np.abs(period - avg) < 1.0) + and (power > 0.005) + ): flag = 0 if flag == 100: flag = 5 return flag - def averaged_per_sector(self, tab): - """ Looks at targets observed in different sectors and determines + """Looks at targets observed in different sectors and determines which period measured is likely the best period. Adds a column - to MeasureRotations.LS_results of 'true_period_days' for the + to MeasureRotations.LS_results of 'true_period_days' for the results. Returns ------- astropy.table.Table """ + def flag_em(val, mode, lim): - if np.abs(val-mode) < lim: + if np.abs(val - mode) < lim: return 0 else: return 1 @@ -325,63 +389,65 @@ def flag_em(val, mode, lim): limit = 0.3 for tic in np.unique(self.IDs): - inds = np.where(tab['Target_ID']==tic)[0] - primary = tab['period_days'].data[inds] - secondary = tab['secondary_period_days'].data[inds] + inds = np.where(tab["Target_ID"] == tic)[0] + primary = tab["period_days"].data[inds] + secondary = tab["secondary_period_days"].data[inds] all_periods = np.append(primary, secondary) -# ind_flags = np.append(tab['oflag1'].data[inds], -# tab['oflag2'].data[inds]) + # ind_flags = np.append(tab['oflag1'].data[inds], + # tab['oflag2'].data[inds]) avg = np.array([]) tflags = np.array([]) if len(inds) > 1: try: - mode = stats.mode(np.round(all_periods,2)) + mode = stats.mode(np.round(all_periods, 2)) if mode > 11.5: avg = np.full(np.nanmean(primary), len(inds)) tflags = np.full(2, len(inds)) else: for i in range(len(inds)): - if np.abs(primary[i]-mode) < limit: + if np.abs(primary[i] - mode) < limit: avg = np.append(avg, primary[i]) - tflags = np.append(tflags,0) - - elif np.abs(secondary[i]-mode) < limit: + tflags = np.append(tflags, 0) + + elif np.abs(secondary[i] - mode) < limit: avg = np.append(avg, secondary[i]) - tflags = np.append(tflags,1) - - elif np.abs(primary[i]/2.-mode) < limit: - avg = np.append(avg, primary[i]/2.) - tflags = np.append(tflags,0) - - elif np.abs(secondary[i]/2.-mode) < limit: - avg = np.append(avg, secondary[i]/2.) - tflags = np.append(tflags,1) - - elif np.abs(primary[i]*2.-mode) < limit: - avg = np.append(avg, primary[i]*2.) - tflags = np.append(tflags,0) - - elif np.abs(secondary[i]*2.-mode) < limit: - avg = np.append(avg, secondary[i]*2.) - tflags = np.append(tflags,1) - + tflags = np.append(tflags, 1) + + elif np.abs(primary[i] / 2.0 - mode) < limit: + avg = np.append(avg, primary[i] / 2.0) + tflags = np.append(tflags, 0) + + elif np.abs(secondary[i] / 2.0 - mode) < limit: + avg = np.append(avg, secondary[i] / 2.0) + tflags = np.append(tflags, 1) + + elif np.abs(primary[i] * 2.0 - mode) < limit: + avg = np.append(avg, primary[i] * 2.0) + tflags = np.append(tflags, 0) + + elif np.abs(secondary[i] * 2.0 - mode) < limit: + avg = np.append(avg, secondary[i] * 2.0) + tflags = np.append(tflags, 1) + else: tflags = np.append(tflags, 2) except: for i in range(len(inds)): - if tab['oflag1'].data[inds[i]]==0 and tab['oflag2'].data[inds[i]]==0: - avg = np.append(avg, tab['period_days'].data[inds[i]]) + if ( + tab["oflag1"].data[inds[i]] == 0 + and tab["oflag2"].data[inds[i]] == 0 + ): + avg = np.append(avg, tab["period_days"].data[inds[i]]) tflags = np.append(tflags, 0) else: - tflags = np.append(tflags,2) - - + tflags = np.append(tflags, 2) + else: avg = np.nanmean(primary) - if tab['oflag1'].data[inds] == 0 and tab['oflag2'].data[inds]==0: + if tab["oflag1"].data[inds] == 0 and tab["oflag2"].data[inds] == 0: tflags = 0 else: tflags = 2 @@ -389,14 +455,12 @@ def flag_em(val, mode, lim): averaged_periods[inds] = np.nanmean(avg) flagging[inds] = tflags - - tab.add_column(Column(flagging, 'Flags')) - tab.add_column(Column(averaged_periods, 'avg_period_days')) + tab.add_column(Column(flagging, "Flags")) + tab.add_column(Column(averaged_periods, "avg_period_days")) return tab - def phase_lightcurve(self, table=None, trough=-0.5, peak=0.5, kernel_size=101): - """ + """ Finds and creates a phase light curve that traces the spots. Uses only complete rotations and extrapolates outwards until the entire light curve is covered. @@ -405,7 +469,7 @@ def phase_lightcurve(self, table=None, trough=-0.5, peak=0.5, kernel_size=101): ---------- table : astropy.table.Table, optional Used for getting the periods of each light curve. Allows users - to use already created tables. Default = None. Will search for + to use already created tables. Default = None. Will search for stella.FindTheSpots.LS_results. trough : float, optional Sets the phase value at the minimum. Default = -0.5. @@ -418,24 +482,27 @@ def phase_lightcurve(self, table=None, trough=-0.5, peak=0.5, kernel_size=101): ---------- phases : np.ndarray """ + def map_per_orbit(time, flux, kernel_size, cadences): mf = medfilt(flux, kernel_size=kernel_size) argmin = np.argmin(mf[:cadences]) - mapping = np.linspace(0.5,-0.5, cadences) + mapping = np.linspace(0.5, -0.5, cadences) phase = np.ones(len(flux)) - full = int(np.floor(len(time)/cadences)) - - phase[0:argmin] = mapping[len(mapping)-argmin:] - - points = np.arange(argmin, cadences*(full+1)+argmin, cadences, dtype=int) - for i in range(len(points)-1): + full = int(np.floor(len(time) / cadences)) + + phase[0:argmin] = mapping[len(mapping) - argmin :] + + points = np.arange( + argmin, cadences * (full + 1) + argmin, cadences, dtype=int + ) + for i in range(len(points) - 1): try: - phase[points[i]:points[i+1]] = mapping + phase[points[i] : points[i + 1]] = mapping except: pass - remainder = len(np.where(phase==1.0)[0]) - phase[len(phase)-remainder:] = mapping[0:remainder] + remainder = len(np.where(phase == 1.0)[0]) + phase[len(phase) - remainder :] = mapping[0:remainder] return phase if table is None: @@ -444,28 +511,30 @@ def map_per_orbit(time, flux, kernel_size, cadences): PHASES = np.copy(self.flux) for i in tqdm(range(len(table)), desc="Mapping phases"): - flag = table['Flags'].data[i] + flag = table["Flags"].data[i] if flag == 0 or flag == 1: - period = table['avg_period_days'].data[i] * u.day - cadences = int(np.round((period.to(u.min)/2).value)) + period = table["avg_period_days"].data[i] * u.day + cadences = int(np.round((period.to(u.min) / 2).value)) all_time = self.time[i] all_flux = self.flux[i] - + diff = np.diff(all_time) - gaptime = np.where(diff>=np.nanmedian(diff)+12*np.nanstd(diff))[0][0] - - t1, f1 = all_time[:gaptime+1], all_flux[:gaptime+1] - t2, f2 = all_time[gaptime+1:], all_flux[gaptime+1:] - + gaptime = np.where(diff >= np.nanmedian(diff) + 12 * np.nanstd(diff))[ + 0 + ][0] + + t1, f1 = all_time[: gaptime + 1], all_flux[: gaptime + 1] + t2, f2 = all_time[gaptime + 1 :], all_flux[gaptime + 1 :] + o1map = map_per_orbit(t1, f1, kernel_size=101, cadences=cadences) o2map = map_per_orbit(t2, f2, kernel_size=101, cadences=cadences) - + phase = np.append(o1map, o2map) else: phase = np.zeros(len(self.flux[i])) - + PHASES[i] = phase self.phases = PHASES diff --git a/stella/tests/conftest.py b/stella/tests/conftest.py new file mode 100644 index 0000000..2d18af7 --- /dev/null +++ b/stella/tests/conftest.py @@ -0,0 +1,65 @@ +import os +import warnings +from pathlib import Path +import pytest +import sys + + +def pytest_addoption(parser): + parser.addoption( + "--run-integration", + action="store_true", + default=False, + help="Run integration tests (downloads/models). Off by default.", + ) + + +def pytest_configure(config): + config.addinivalue_line( + "markers", "integration: marks tests as integration (requires network/models)" + ) + config.addinivalue_line( + "markers", + "downloads: marks tests that may download small data; allowed by default", + ) + + +def pytest_collection_modifyitems(config, items): + if config.getoption("--run-integration"): + return + skip_integration = pytest.mark.skip( + reason="Integration tests are disabled. Use --run-integration to enable." + ) + for item in items: + if "integration" in item.keywords: + item.add_marker(skip_integration) + + +def pytest_sessionstart(session): + # Ensure Lightkurve uses the new cache path to avoid migration warnings + os.environ.setdefault( + "LIGHTKURVE_CACHE_DIR", str(Path.home() / ".lightkurve" / "cache") + ) + # Silence optional dependency warnings from Lightkurve PRF module + warnings.filterwarnings( + "ignore", message=r".*tpfmodel submodule is not available.*" + ) + warnings.filterwarnings("ignore", message=r".*Lightkurve cache directory.*") + + +@pytest.fixture(autouse=True) +def _debug_backend(request): + """Print concise backend diagnostics for each test function.""" + be = os.environ.get("KERAS_BACKEND") + imported = "keras" in sys.modules + current = None + if imported: + try: + import keras # type: ignore + + current = keras.backend.backend() + except Exception: + current = "" + print( + f"[test {request.node.nodeid}] KERAS_BACKEND={be} keras_imported={imported} current={current}" + ) diff --git a/stella/tests/test_backends.py b/stella/tests/test_backends.py new file mode 100644 index 0000000..19b53f8 --- /dev/null +++ b/stella/tests/test_backends.py @@ -0,0 +1,61 @@ +import pytest +import os +import sys + + +def _run_minimal_model(expect_backend: str): + import keras + import numpy as np + + assert keras.backend.backend() == expect_backend + # Minimal dense network + m = keras.Sequential( + [ + keras.layers.Input((20,)), + keras.layers.Dense(16, activation="relu"), + keras.layers.Dense(1, activation="sigmoid"), + ] + ) + x = np.random.RandomState(0).randn(4, 20).astype("float32") + y = m(x, training=False) + assert y.shape == (4, 1) + + +def test_minimal_jax(): + pytest.importorskip("jax") + # Only run if keras is either not imported or already using jax + if "keras" in sys.modules: + import keras + + if keras.backend.backend() != "jax": + return # skip if another backend is already active in this process + else: + os.environ["KERAS_BACKEND"] = "jax" + _run_minimal_model("jax") + + +def test_minimal_torch(): + torch = pytest.importorskip("torch") + if hasattr(torch.backends, "mps"): + # If MPS is present, verify it's actually usable (not just detected). + if not (torch.backends.mps.is_available() and torch.backends.mps.is_built()): + pytest.skip("MPS backend not available or not built.") + # Try a tiny allocation on MPS to detect early OOM / unusable MPS devices. + try: + # This small allocation can raise RuntimeError if MPS is unusable/out of memory. + _ = torch.zeros(1, device="mps") + except RuntimeError as e: + msg = str(e).lower() + if "mps backend out of memory" in msg or "mps" in msg and "out of memory" in msg: + pytest.skip("MPS backend present but out of memory; skipping MPS-based torch test.") + # if it's another runtime error, re-raise so we don't silently mask real issues + raise + + # Only run if keras is either not imported or already using torch + if "keras" in sys.modules: + import keras + if keras.backend.backend() != "torch": + return # skip if another backend is already active + else: + os.environ["KERAS_BACKEND"] = "torch" + _run_minimal_model("torch") \ No newline at end of file diff --git a/stella/tests/test_mark_flares.py b/stella/tests/test_mark_flares.py index 8d3c77b..eebf4bd 100644 --- a/stella/tests/test_mark_flares.py +++ b/stella/tests/test_mark_flares.py @@ -1,31 +1,88 @@ import numpy as np -from stella import ConvNN -from stella import FitFlares -from lightkurve.search import search_lightcurve +import pytest from numpy.testing import assert_almost_equal -lk = search_lightcurve(target='tic62124646', mission='TESS', - exptime=120, sector=13, author='SPOC') -lk = lk.download(download_dir='.') -lk = lk.remove_nans().normalize() -modelname = 'ensemble_s0002_i0010_b0.73.h5' +pytestmark = pytest.mark.integration + + +def _load_lc(): + from lightkurve.search import search_lightcurve + + lk = search_lightcurve( + target="tic62124646", mission="TESS", exptime=120, sector=13, author="SPOC" + ) + lk = lk.download(download_dir=".") + lk = lk.remove_nans().normalize() + return lk -cnn = ConvNN(output_dir='.') def test_predictions(): - cnn.predict(modelname=modelname, - times=lk.time.value, - fluxes=lk.flux.value, - errs=lk.flux_err.value) - high_flares = np.where(cnn.predictions[0]>0.99)[0] - assert(len(high_flares) == 0) - -def find_flares(): - flares = FitFlares(id=[lk.targetid], - time=[lk.time.value], - flux=[lk.flux.value], - flux_err=[lk.flux_err.value], - predictions=[cn.predictions[0]]) + from stella.neural_network import ConvNN + from stella import models as sm + + lk = _load_lc() + modelname = sm.get_model_path() + cnn = ConvNN(output_dir=".") + cnn.predict( + modelname=modelname, + times=lk.time.value, + fluxes=lk.flux.value, + errs=lk.flux_err.value, + ) + high_flares = np.where(cnn.predictions[0] > 0.99)[0] + assert len(high_flares) == 0 + + +def test_find_flares_no_candidates(): + from stella.mark_flares import FitFlares + + lk = _load_lc() + flares = FitFlares( + id=[lk.targetid], + time=[lk.time.value], + flux=[lk.flux.value], + flux_err=[lk.flux_err.value], + predictions=[np.zeros_like(lk.flux.value)], + ) flares.identify_flare_peaks() - assert(len(flares.flare_table)==0) + assert len(flares.flare_table) == 0 + + +def test_identify_flare_peaks_handles_ragged_object_dtype(): + """ + Regression test: previously, ragged/object-dtype inputs caused SciPy medfilt + to error in identify_flare_peaks. This ensures no exceptions and empty table + for zero predictions. + """ + from stella.mark_flares import FitFlares + + lk = _load_lc() + + # Create ragged light curve inputs (different lengths) and wrap in object arrays + t1 = lk.time.value + f1 = lk.flux.value + e1 = lk.flux_err.value + p1 = np.zeros_like(f1) + + t2 = lk.time.value[:-5] + f2 = lk.flux.value[:-5] + e2 = lk.flux_err.value[:-5] + p2 = np.zeros_like(f2) + + ids = np.array([lk.targetid, lk.targetid], dtype=object) + time = np.array([t1, t2], dtype=object) + flux = np.array([f1, f2], dtype=object) + err = np.array([e1, e2], dtype=object) + preds = np.array([p1, p2], dtype=object) + + flares = FitFlares(id=ids, time=time, flux=flux, flux_err=err, predictions=preds) + + # Should not raise, and with zero predictions there should be no flares + flares.identify_flare_peaks(threshold=0.5) + assert len(flares.flare_table) == 0 + + # Spot-check grouping behavior returns object-dtype array for ragged groups + groups = flares.group_inds(np.array([1, 2, 10, 11, 12, 40])) + assert groups.dtype == object + assert any(len(g) == 2 for g in groups) and any(len(g) == 3 for g in groups) diff --git a/stella/tests/test_neural_network.py b/stella/tests/test_neural_network.py index 25bc3a8..955ff80 100644 --- a/stella/tests/test_neural_network.py +++ b/stella/tests/test_neural_network.py @@ -1,69 +1,86 @@ -from stella.metrics import * -from stella.download_nn_set import * -from stella.preprocessing_flares import * -from stella.neural_network import * +import pytest from numpy.testing import assert_almost_equal +from stella import models as sm -download = DownloadSets(fn_dir='.') -download.download_catalog() -download.flare_table = download.flare_table[0:20] -download.download_lightcurves(remove_fits=False) -pre = FlareDataSet(downloadSet=download) +pytestmark = pytest.mark.downloads # allow network, avoid training -def test_catalog_retrieval(): - assert(download.flare_table['TIC'][0] == 2760232) - assert_almost_equal(download.flare_table['tpeak'][10], 2458368.8, decimal=1) - assert(download.flare_table['Flare'][9] == 3) -def test_light_curves(): - download.download_lightcurves(remove_fits=False) +def test_keras_backend_is_jax(): + import os + pytest.importorskip("jax") -def test_processing(): - assert_almost_equal(pre.frac_balance, 0.7, decimal=1) - assert(pre.train_data.shape == (48, 200, 1)) - assert(pre.val_data.shape == (6, 200, 1)) - assert(pre.test_data.shape == (7, 200, 1)) + os.environ["KERAS_BACKEND"] = "jax" + import keras -def test_tensorflow(): - import tensorflow - assert(tensorflow.__version__ == '2.4.1') + assert keras.backend.backend() == "jax" -cnn = ConvNN(output_dir='.', ds=pre) -cnn.train_models(epochs=10, save=True, pred_test=True) -def test_train_model(): - assert(cnn.loss == 'binary_crossentropy') - assert(cnn.optimizer == 'adam') - assert(cnn.training_ids[10] == 2760232.0) - assert(cnn.frac_balance == 0.73) - assert(len(cnn.val_pred_table) == 6) +def test_predict(tmp_path): + from lightkurve.search import search_lightcurve + from stella.neural_network import ConvNN + model_path = sm.get_model_path() + lk = search_lightcurve( + target="tic62124646", mission="TESS", sector=13, exptime=120, author="SPOC" + ) + lk = lk.download(download_dir=".") + lk = lk.remove_nans().normalize() + cnn = ConvNN(output_dir=".") + import numpy as np -def test_predict(): - from lightkurve.search import search_lightcurve + err_arr = ( + lk.flux_err.value + if getattr(lk, "flux_err", None) is not None + else np.zeros_like(lk.time.value) + ) + cnn.predict( + modelname=model_path, + times=lk.time.value, + fluxes=lk.flux.value, + errs=err_arr, + verbose=False, + ) + assert cnn.predictions.shape[0] == 1 + assert cnn.predictions[0].shape[0] == len(lk.time.value) - lk = search_lightcurve(target='tic62124646', mission='TESS', - sector=13, exptime=120, author='SPOC') - lk = lk.download(download_dir='.')#.PDCSAP_FLUX - lk = lk.remove_nans() - cnn.predict(modelname='ensemble_s0002_i0010_b0.73.h5', - times=lk.time.value, - fluxes=lk.flux.value, - errs=lk.flux_err.value) - assert(cnn.predictions.shape == (1,17939)) - assert_almost_equal(cnn.predictions[0][1000], 0.3, decimal=1) +def _write_dummy_metrics_dir(tmp_path): + from astropy.table import Table + import numpy as np -metrics = ModelMetrics(fn_dir='.') + (tmp_path / "ensemble_s0002_i0010_b0.73.keras").write_text("placeholder") + n = 10 + tab = Table() + tab["tic"] = np.arange(n) + tab["gt"] = np.random.randint(0, 2, size=n) + tab["tpeak"] = np.linspace(0, 1, n) + tab["pred_s0002"] = np.random.rand(n) + tab.write( + tmp_path / "ensemble_predval_i0010_b0.73.txt", format="ascii", overwrite=True + ) + h = Table() + h["precision_s0002"] = np.random.rand(5) + h.write( + tmp_path / "ensemble_histories_i0010_b0.73.txt", format="ascii", overwrite=True + ) + return str(tmp_path) -def test_create_metrics(): - assert(metrics.mode == 'ensemble') - assert(len(metrics.predtest_table)==7) - assert(metrics.predval_table['gt'][0] == 1) - assert(metrics.history_table.colnames[2] == 'precision_s0002') -def test_ensemble(): - metrics.calculate_ensemble_metrics() +def test_create_metrics(tmp_path): + from stella.metrics import ModelMetrics + + fn_dir = _write_dummy_metrics_dir(tmp_path) + metrics = ModelMetrics(fn_dir=fn_dir) + assert metrics.mode == "ensemble" + assert len(metrics.predval_table) > 0 + assert metrics.history_table.colnames[0].startswith("precision") - assert(metrics.ensemble_accuracy == 0.0) - assert(metrics.ensemble_avg_precision == 1.0) + +def test_ensemble(tmp_path): + from stella.metrics import ModelMetrics + + fn_dir = _write_dummy_metrics_dir(tmp_path) + metrics = ModelMetrics(fn_dir=fn_dir) + metrics.calculate_ensemble_metrics() + assert 0.0 <= metrics.ensemble_accuracy <= 1.0 + assert 0.0 <= metrics.ensemble_avg_precision <= 1.0 diff --git a/stella/tests/test_processing.py b/stella/tests/test_processing.py index 3154c54..0293ea9 100644 --- a/stella/tests/test_processing.py +++ b/stella/tests/test_processing.py @@ -1,11 +1,18 @@ -from stella.preprocessing_flares import * +import pytest from numpy.testing import assert_almost_equal -pre = FlareDataSet(fn_dir='.', - catalog='Guenther_2020_flare_catalog.txt') +pytestmark = pytest.mark.integration + + +def _make_dataset(): + from stella.preprocessing_flares import FlareDataSet + + return FlareDataSet(fn_dir=".", catalog="Guenther_2020_flare_catalog.txt") + def test_processing(): + pre = _make_dataset() assert_almost_equal(pre.frac_balance, 0.7, decimal=1) - assert(pre.train_data.shape == (62, 200, 1)) - assert(pre.val_data.shape == (8, 200, 1)) - assert(pre.test_data.shape == (8, 200, 1)) + assert pre.train_data.shape == (62, 200, 1) + assert pre.val_data.shape == (8, 200, 1) + assert pre.test_data.shape == (8, 200, 1) diff --git a/stella/tests/test_rotation.py b/stella/tests/test_rotation.py index 39003ca..a2ecc3b 100644 --- a/stella/tests/test_rotation.py +++ b/stella/tests/test_rotation.py @@ -1,18 +1,25 @@ -from stella.rotations import MeasureProt -from lightkurve.search import search_lightcurve +import pytest from numpy.testing import assert_almost_equal -lk = search_lightcurve(target='tic62124646', mission='TESS', - exptime=120, sector=13, author='SPOC') -lk = lk.download(download_dir='.') -lk = lk.remove_nans().normalize() -mProt = MeasureProt([lk.targetid], [lk.time.value], - [lk.flux.value], [lk.flux_err.value]) -mProt.run_LS() +def _load_lc(): + from lightkurve.search import search_lightcurve + + lk = search_lightcurve( + target="tic62124646", mission="TESS", exptime=120, sector=13, author="SPOC" + ) + lk = lk.download(download_dir=".") + lk = lk.remove_nans().normalize() + return lk + def test_measurement(): - assert_almost_equal(mProt.LS_results['period_days'], 3.2, decimal=1) - assert(mProt.LS_results['Flags']==0) + from stella.rotations import MeasureProt - + lk = _load_lc() + mProt = MeasureProt( + [lk.targetid], [lk.time.value], [lk.flux.value], [lk.flux_err.value] + ) + mProt.run_LS() + assert_almost_equal(mProt.LS_results["period_days"], 3.2, decimal=1) + assert mProt.LS_results["Flags"] == 0 diff --git a/stella/tests/test_swap_backend.py b/stella/tests/test_swap_backend.py new file mode 100644 index 0000000..3f8659f --- /dev/null +++ b/stella/tests/test_swap_backend.py @@ -0,0 +1,68 @@ +import json +import os +import sys +import subprocess +import pytest + + +def _run_py(code: str, env: dict) -> tuple[int, str, str]: + p = subprocess.Popen( + [sys.executable, "-c", code], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + env=env, + ) + out, err = p.communicate() + return p.returncode, out.strip(), err.strip() + + +def test_swap_backend_basic(): + # Discover available backends + rc, out, err = _run_py( + "import json, stella; print(json.dumps(stella.check_backend(print_summary=False)))", + {k: v for k, v in os.environ.items() if k != "KERAS_BACKEND"}, + ) + assert rc == 0, err + info = json.loads(out) + cands = info.get("candidates", []) + if not cands: + pytest.skip("No Keras backends installed") + + for be in cands: + code = ( + "import os; from stella.backends import swap_backend; " + f"swap_backend('{be}'); import keras; print(keras.backend.backend())" + ) + rc, out, err = _run_py( + code, {k: v for k, v in os.environ.items() if k != "KERAS_BACKEND"} + ) + assert rc == 0, err + assert out == be + + +def test_swap_backend_accelerator_mps_if_available(): + # Only relevant if Torch with MPS is available + rc, out, err = _run_py( + "import json, stella; print(json.dumps(stella.check_backend(print_summary=False)))", + os.environ, + ) + assert rc == 0, err + info = json.loads(out) + torch = info.get("torch", {}) + details = torch.get("details", {}) + if not (torch.get("installed") and details.get("mps")): + pytest.skip("Torch MPS not available on this runner") + + code = ( + "from stella.backends import swap_backend; " + "swap_backend('torch', accelerator='mps'); " + "import keras, numpy as np; " + "m = keras.Sequential([keras.layers.Input((8,)), keras.layers.Dense(4, activation='relu')]); " + "y = m(np.zeros((2,8), dtype='float32')); print(keras.backend.backend(), y.shape)" + ) + rc, out, err = _run_py( + code, {k: v for k, v in os.environ.items() if k != "KERAS_BACKEND"} + ) + assert rc == 0, err + assert out.startswith("torch ") or out.startswith("torch,") diff --git a/stella/tests/test_training_guards.py b/stella/tests/test_training_guards.py new file mode 100644 index 0000000..25b580c --- /dev/null +++ b/stella/tests/test_training_guards.py @@ -0,0 +1,17 @@ +import pytest + + +def test_create_model_raises_without_dataset(): + from stella.neural_network import ConvNN + + cnn = ConvNN(output_dir='.') + with pytest.raises(ValueError): + cnn.create_model(seed=2) + + +def test_train_models_raises_without_dataset(): + from stella.neural_network import ConvNN + + cnn = ConvNN(output_dir='.') + with pytest.raises(ValueError): + cnn.train_models(seeds=[2], epochs=1, batch_size=4) diff --git a/stella/utils.py b/stella/utils.py index f9d1a83..158fa2c 100755 --- a/stella/utils.py +++ b/stella/utils.py @@ -2,9 +2,10 @@ from astropy import units as uni from scipy.interpolate import interp1d + def flare_lightcurve(time, t0, amp, rise, fall, y=None): """ - Generates a simple flare model with a Gaussian rise and an + Generates a simple flare model with a Gaussian rise and an exponential decay. Parameters @@ -27,26 +28,27 @@ def flare_lightcurve(time, t0, amp, rise, fall, y=None): flare_model : np.ndarray A light curve of zeros with an injected flare of given parameters row : np.ndarray - The parameters of the injected flare. Returns - + The parameters of the injected flare. Returns - [t0, amplitude, duration, gauss_rise, exp_decay]. """ + def gauss_rise(time, flux, amp, t0, rise): - return amp * np.exp( -(time - t0)**2.0 / (2.0*rise**2.0) ) + flux - + return amp * np.exp(-((time - t0) ** 2.0) / (2.0 * rise**2.0)) + flux + def exp_decay(time, flux, amp, t0, fall): - return amp * np.exp( -(time - t0) / fall ) + flux + return amp * np.exp(-(time - t0) / fall) + flux growth = np.where(time <= time[t0])[0] - decay = np.where(time > time[t0])[0] + decay = np.where(time > time[t0])[0] if y is None: y = np.ones(len(time)) growth_model = gauss_rise(time[growth], y[growth], amp, time[t0], rise) - decay_model = exp_decay(time[decay] , y[decay] , amp, time[t0], fall) + decay_model = exp_decay(time[decay], y[decay], amp, time[t0], fall) model = np.append(growth_model, decay_model) - + return model, np.array([time[t0], amp, 0, rise, fall]) @@ -61,14 +63,14 @@ def flare_parameters(size, time, amps, cut_ends=30): The number of flares to generate. times : np.array Array of times where a random subset will be chosen for flare - injection. + injection. amps : list - List of minimum and maximum of flare amplitudes to draw from a - normal distribution. + List of minimum and maximum of flare amplitudes to draw from a + normal distribution. cut_ends : int, optional Number of cadences to cut from the ends of the light curve. Default is 30. - + Returns ---------- flare_t0s : np.ndarray @@ -81,13 +83,13 @@ def flare_parameters(size, time, amps, cut_ends=30): The distribution of flare decays rates. """ # CHOOSES UNIQUE TIMES FOR INJ-REC PURPOSES - randtimes = np.random.randint(cut_ends, len(time)-cut_ends, size*2) - randtimes = np.unique(randtimes) - randind = np.random.randint(0, len(randtimes), size) - randtimes = randtimes[randind] + randtimes = np.random.randint(cut_ends, len(time) - cut_ends, size * 2) + randtimes = np.unique(randtimes) + randind = np.random.randint(0, len(randtimes), size) + randtimes = randtimes[randind] - flare_amps = np.random.uniform(amps[0], amps[1], size) - flare_rises = np.random.uniform(0.00005, 0.0002, size) + flare_amps = np.random.uniform(amps[0], amps[1], size) + flare_rises = np.random.uniform(0.00005, 0.0002, size) # Relation between amplitude and decay time flare_decays = np.random.uniform(0.0003, 0.004, size) @@ -119,55 +121,62 @@ def break_rest(time, flux, flux_err, cadences): err : np.ndarray Array of flux errors without the signal. """ - # BREAKING UP REST OF LIGHT CURVE INTO CADENCE SIZED BITES + # BREAKING UP REST OF LIGHT CURVE INTO CADENCE SIZED BITES diff = np.diff(time) - breaking_points = np.where(diff > (np.median(diff) + 1.5*np.std(diff)))[0] - + breaking_points = np.where(diff > (np.median(diff) + 1.5 * np.std(diff)))[0] + tot = 100 - ss = 1000 + ss = 1000 nonflare_time = np.zeros((ss, cadences)) nonflare_flux = np.zeros((ss, cadences)) nonflare_err = np.zeros((ss, cadences)) - + x = 0 - for j in range(len(breaking_points)+1): + for j in range(len(breaking_points) + 1): if j == 0: start = 0 end = breaking_points[j] elif j < len(breaking_points): - start = breaking_points[j-1] + start = breaking_points[j - 1] end = breaking_points[j] else: start = breaking_points[-1] end = len(time) - if np.abs(end-start) > (2*cadences): + if np.abs(end - start) > (2 * cadences): broken_time = time[start:end] broken_flux = flux[start:end] - broken_err = flux_err[start:end] + broken_err = flux_err[start:end] - # DIVIDE LIGHTCURVE INTO EVEN BINS + # DIVIDE LIGHTCURVE INTO EVEN BINS c = 0 while (len(broken_time) - c) % cadences != 0: c += 1 - # REMOVING CADENCES TO BIN EVENLY INTO CADENCES - temp_time = np.delete(broken_time, np.arange(len(broken_time)-c, - len(broken_time), 1, dtype=int) ) - temp_flux = np.delete(broken_flux, np.arange(len(broken_flux)-c, - len(broken_flux), 1, dtype=int) ) - temp_err = np.delete(broken_err, np.arange(len(broken_err)-c, - len(broken_err), 1, dtype=int) ) - - # RESHAPE ARRAY FOR INPUT INTO MATRIX - temp_time = np.reshape(temp_time, - (int(len(temp_time) / cadences), cadences) ) - temp_flux = np.reshape(temp_flux, - (int(len(temp_flux) / cadences), cadences) ) - temp_err = np.reshape(temp_err, - (int(len(temp_err) / cadences), cadences) ) - - # APPENDS TO BIGGER MATRIX + # REMOVING CADENCES TO BIN EVENLY INTO CADENCES + temp_time = np.delete( + broken_time, + np.arange(len(broken_time) - c, len(broken_time), 1, dtype=int), + ) + temp_flux = np.delete( + broken_flux, + np.arange(len(broken_flux) - c, len(broken_flux), 1, dtype=int), + ) + temp_err = np.delete( + broken_err, + np.arange(len(broken_err) - c, len(broken_err), 1, dtype=int), + ) + + # RESHAPE ARRAY FOR INPUT INTO MATRIX + temp_time = np.reshape( + temp_time, (int(len(temp_time) / cadences), cadences) + ) + temp_flux = np.reshape( + temp_flux, (int(len(temp_flux) / cadences), cadences) + ) + temp_err = np.reshape(temp_err, (int(len(temp_err) / cadences), cadences)) + + # APPENDS TO BIGGER MATRIX for f in range(len(temp_flux)): if x >= ss: break @@ -179,16 +188,16 @@ def break_rest(time, flux, flux_err, cadences): nonflare_time = np.delete(nonflare_time, np.arange(x, ss, 1, dtype=int), axis=0) nonflare_flux = np.delete(nonflare_flux, np.arange(x, ss, 1, dtype=int), axis=0) - nonflare_err = np.delete(nonflare_err, np.arange(x, ss, 1, dtype=int), axis=0) - + nonflare_err = np.delete(nonflare_err, np.arange(x, ss, 1, dtype=int), axis=0) + return nonflare_time, nonflare_flux, nonflare_err - - + + def do_the_shuffle(training_matrix, labels, training_other, training_ids, frac_balance): """ Shuffles the data in a random order and fixes data inbalance based on frac_balance. - + Parameters ---------- training_matrix : np.ndarray @@ -198,39 +207,41 @@ def do_the_shuffle(training_matrix, labels, training_other, training_ids, frac_b training_other : np.array training_ids : np.array frac_balance : float - + Returns ------- """ np.random.seed(321) ind_shuffle = np.random.permutation(training_matrix.shape[0]) - + labels2 = np.copy(labels[ind_shuffle]) matrix2 = np.copy(training_matrix[ind_shuffle]) - other2 = np.copy(training_other[ind_shuffle]) - ids2 = np.copy(training_ids[ind_shuffle]) - - # INDEX OF NEGATIVE CLASS + other2 = np.copy(training_other[ind_shuffle]) + ids2 = np.copy(training_ids[ind_shuffle]) + + # INDEX OF NEGATIVE CLASS ind_nc = np.where(labels2 == 0) - # RANDOMIZE INDEXES + # RANDOMIZE INDEXES np.random.seed(123) ind_nc_rand = np.random.permutation(ind_nc[0]) - - # REMOVE FRAC_BALANCE% OF NEGATIVE CLASS + + # REMOVE FRAC_BALANCE% OF NEGATIVE CLASS length = int(frac_balance * len(ind_nc_rand)) newlabels = np.delete(labels2, ind_nc_rand[0:length]) - newtraining_other = np.delete(other2 , ind_nc_rand[0:length]) - newtraining_ids = np.delete(ids2 , ind_nc_rand[0:length]) + newtraining_other = np.delete(other2, ind_nc_rand[0:length]) + newtraining_ids = np.delete(ids2, ind_nc_rand[0:length]) newtraining_matrix = np.delete(matrix2, ind_nc_rand[0:length], axis=0) - ind_pc = np.where(newlabels==1) - ind_nc = np.where(newlabels==0) + ind_pc = np.where(newlabels == 1) + ind_nc = np.where(newlabels == 0) print("{} positive classes (flare)".format(len(ind_pc[0]))) print("{} negative classes (no flare)".format(len(ind_nc[0]))) - print("{}% class imbalance\n".format(np.round(100 * len(ind_pc[0]) / len(ind_nc[0])))) - + print( + "{}% class imbalance\n".format(np.round(100 * len(ind_pc[0]) / len(ind_nc[0]))) + ) + return newtraining_ids, newtraining_matrix, newlabels, newtraining_other @@ -253,7 +264,7 @@ def split_data(labels, training_matrix, ids, other, training, validation): validatoin : float How much of the data should be in the validation & test set. - Returns + Returns ------- x_train : np.ndarray y_train : np.narray @@ -267,25 +278,36 @@ def split_data(labels, training_matrix, ids, other, training, validation): test_other : np.array """ train_cutoff = int(training * len(labels)) - val_cutoff = int(validation * len(labels)) - + val_cutoff = int(validation * len(labels)) + x_train = training_matrix[0:train_cutoff] y_train = labels[0:train_cutoff] - + x_val = training_matrix[train_cutoff:val_cutoff] y_val = labels[train_cutoff:val_cutoff] - + x_test = training_matrix[val_cutoff:] y_test = labels[val_cutoff:] - + x_train = x_train.reshape(x_train.shape[0], x_train.shape[1], 1) - x_val = x_val.reshape(x_val.shape[0], x_train.shape[1], 1) - x_test = x_test.reshape(x_test.shape[0], x_test.shape[1], 1) + x_val = x_val.reshape(x_val.shape[0], x_train.shape[1], 1) + x_test = x_test.reshape(x_test.shape[0], x_test.shape[1], 1) - test_ids = ids[val_cutoff:] + test_ids = ids[val_cutoff:] test_other = other[val_cutoff:] - - val_ids = ids[train_cutoff:val_cutoff] + + val_ids = ids[train_cutoff:val_cutoff] val_other = other[train_cutoff:val_cutoff] - - return x_train, y_train, x_val, y_val, val_ids, val_other, x_test, y_test, test_ids, test_other + + return ( + x_train, + y_train, + x_val, + y_val, + val_ids, + val_other, + x_test, + y_test, + test_ids, + test_other, + ) diff --git a/stella/version.py b/stella/version.py index 54f0b0c..493f741 100755 --- a/stella/version.py +++ b/stella/version.py @@ -1 +1 @@ -__version__ = "0.2.0rc2" +__version__ = "0.3.0" diff --git a/stella/visualize.py b/stella/visualize.py index b4320b4..052c407 100755 --- a/stella/visualize.py +++ b/stella/visualize.py @@ -3,14 +3,15 @@ from pylab import * import matplotlib.pyplot as plt -__all__ = ['Visualize'] +__all__ = ["Visualize"] + class Visualize(object): """ Creates diagnostic plots for the neural network. """ - def __init__(self, cnn, set='validation'): + def __init__(self, cnn, set="validation"): """ Initialized visualization class. @@ -21,17 +22,17 @@ def __init__(self, cnn, set='validation'): An option to view the results of the validation set or the testing set. The testing set should only be looked at at - the very end of creating, training, and + the very end of creating, training, and testing the network using the validation set. - Default is 'validation'. The alternative + Default is 'validation'. The alternative option is 'test'. """ self.cnn = cnn self.set = set - if set.lower() == 'validation': + if set.lower() == "validation": self.data_set = cnn.val_data - if set.lower() == 'test': + if set.lower() == "test": self.data_set = cnn.test_data if cnn.history is not None: @@ -39,15 +40,14 @@ def __init__(self, cnn, set='validation'): if cnn.history_table is not None: self.history_table = cnn.history_table - self.epochs = cnn.epochs + self.epochs = cnn.epochs if cnn.prec_recall_curve is not None: self.prec_recall = cnn.prec_recall_curve else: self.prec_recall = None - - def loss_acc(self, train_color='k', val_color='darkorange'): + def loss_acc(self, train_color="k", val_color="darkorange"): """ Plots the loss & accuracy curves for the training and validation sets. @@ -61,28 +61,31 @@ def loss_acc(self, train_color='k', val_color='darkorange'): dark orange. """ epochs = np.arange(0, self.epochs, 1) - fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(14,4)) - - ax1.plot(epochs, self.history['loss'], c=train_color, - linewidth=2, label='Training') - ax1.plot(epochs, self.history['val_loss'], c=val_color, - linewidth=2, label='Validation') - ax1.set_xlabel('Epochs') - ax1.set_ylabel('Loss') + fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(14, 4)) + + ax1.plot( + epochs, self.history["loss"], c=train_color, linewidth=2, label="Training" + ) + ax1.plot( + epochs, + self.history["val_loss"], + c=val_color, + linewidth=2, + label="Validation", + ) + ax1.set_xlabel("Epochs") + ax1.set_ylabel("Loss") ax1.legend() - ax2.plot(epochs, self.history['accuracy'], c=train_color, - linewidth=2) - ax2.plot(epochs, self.history['val_accuracy'], c=val_color, - linewidth=2) - ax2.set_xlabel('Epochs') - ax2.set_ylabel('Accuracy') - + ax2.plot(epochs, self.history["accuracy"], c=train_color, linewidth=2) + ax2.plot(epochs, self.history["val_accuracy"], c=val_color, linewidth=2) + ax2.set_xlabel("Epochs") + ax2.set_ylabel("Accuracy") + plt.subplots_adjust() return fig - def precision_recall(self, **kwargs): """ Plots the ensemble-averaged precision recall metric. @@ -92,19 +95,18 @@ def precision_recall(self, **kwargs): **kwargs : dictionary, optional Dictionary of parameters to pass into matplotlib. """ - fig = plt.figure(figsize=(8,5)) + fig = plt.figure(figsize=(8, 5)) plt.plot(self.prec_recall[0], self.prec_recall[1], **kwargs) - plt.xlabel('Recall') - plt.ylabel('Precision') + plt.xlabel("Recall") + plt.ylabel("Precision") return fig - - def confusion_matrix(self, threshold=0.5, colormap='inferno'): + def confusion_matrix(self, threshold=0.5, colormap="inferno"): """ Plots the confusion matrix of true positives, - true negatives, false positives, and false + true negatives, false positives, and false negatives. Parameters @@ -123,14 +125,13 @@ def confusion_matrix(self, threshold=0.5, colormap='inferno'): rgb = cmap(i)[:3] colors.append(matplotlib.colors.rgb2hex(rgb)) colors = np.array(colors) - + # PLOTTING NORMALIZED LIGHT CURVE TO GIVEN SUBPLOT def plot_lc(data, ind, ax, color, offset): - """ Plots the light curve on a given axis. """ - ax.set_xlim(0,200) - ax.set_ylim(-3,3.5) - ax.axvline(100, linestyle='dotted', color='gray', - linewidth=0.5) + """Plots the light curve on a given axis.""" + ax.set_xlim(0, 200) + ax.set_ylim(-3, 3.5) + ax.axvline(100, linestyle="dotted", color="gray", linewidth=0.5) ax.set_yticks([]) ax.set_xticks([]) @@ -147,33 +148,36 @@ def plot_lc(data, ind, ax, color, offset): x_val = self.data_set + 0.0 # INDICES FOR THE CONFUSION MATRIX - ind_tn = np.where( (df['pred_round'] == 0) & (df['gt'] == 0) )[0] - ind_fn = np.where( (df['pred_round'] == 0) & (df['gt'] == 1) )[0] - ind_tp = np.where( (df['pred_round'] == 1) & (df['gt'] == 1) )[0] - ind_fp = np.where( (df['pred_round'] == 1) & (df['gt'] == 0) )[0] - - order = [ind_tn, ind_fp, ind_fn, ind_tp] - titles = ['True Negatives', 'False Positives', - 'False Negatives', 'True Positives'] + ind_tn = np.where((df["pred_round"] == 0) & (df["gt"] == 0))[0] + ind_fn = np.where((df["pred_round"] == 0) & (df["gt"] == 1))[0] + ind_tp = np.where((df["pred_round"] == 1) & (df["gt"] == 1))[0] + ind_fp = np.where((df["pred_round"] == 1) & (df["gt"] == 0))[0] + + order = [ind_tn, ind_fp, ind_fn, ind_tp] + titles = [ + "True Negatives", + "False Positives", + "False Negatives", + "True Positives", + ] shifts = [-2, 0, 2] - fig, axes = plt.subplots(ncols=2, nrows=2, figsize=(10,8)) + fig, axes = plt.subplots(ncols=2, nrows=2, figsize=(10, 8)) i = 0 - + for ax in axes.reshape(-1): inds = order[i] - which = np.random.randint(0,len(inds),3) - + which = np.random.randint(0, len(inds), 3) + for j in range(3): - ax = plot_lc(x_val, inds[which[j]], ax, colors[j*2+1], - shifts[j]) - + ax = plot_lc(x_val, inds[which[j]], ax, colors[j * 2 + 1], shifts[j]) + ax.set_title(titles[i], fontsize=20) - if titles[i] == 'False Positives' or titles[i] == 'False Negatives': - ax.set_facecolor('lightgray') + if titles[i] == "False Positives" or titles[i] == "False Negatives": + ax.set_facecolor("lightgray") i += 1 - + return fig